你能帮我解决我的递归 function 吗？

Question

I have this simple function that I am calculating correctly, but my output statements are off. I have tried other places were the cout statement is commented, but not working.

int recursiveFunc(int n) {
    int val;    // value at nth sequence


    //cout << "(" << n << ") = " << val << endl;

    if (n == 1 ) {      // base case 1
        val = -1;
        // outputs before function call
    }
    else if (n == 2) {  // base case 2
        val = -1;
        // outputs before function call
    }
    else {      // recursive case
        //cout << "(" << n << ") = << val << endl;
        val = 2*(recursiveFunc(n-1) + recursiveFunc(n-2));
        cout << "(" << n << ") = " << val << endl;   // not sure where to put cout statement

    }

    return val;
}

I am looking for an output like (for example n = 5):

(1) = -1
(2) = -1
(3) = -4
(4) = -10
(5) = -28

currently, my output looks like:

(1) = -1
(2) = -1
(3) = -4
(4) = -10
(3) = -4    // here an nth term is displayed twice
(5) = -28

Answer 1

Move your cout statement to outside the function and it works fine.

int recursiveFunc(int n) {
    int val;    // value at nth sequence

    if (n == 1) {      // base case 1
        val = -1;
    }
    else if (n == 2) {  // base case 2
        val = -1;
    }
    else {      // recursive case
        val = 2 * (recursiveFunc(n - 1) + recursiveFunc(n - 2));
    }

    return val;
}

int main() {
    for (int i = 1; i < 10; i++) {

        std::cout << "(" << i << ") = " << recursiveFunc(i) << endl;
    }
    return 0;
}

Output:

(1) = -1
(2) = -1
(3) = -4
(4) = -10
(5) = -28
(6) = -76
(7) = -208
(8) = -568
(9) = -1552

Answer 2

Right off the top-of-my-head, a possible fix is to keep track of the highest n output so-far already and only output when a larger n is encountered. (This is probably not the best solution, but I'm feeling too tired and lazy to think about alternatives)

Don't use a global variable for this ( mutable global state is an anti-pattern! ) - you'll need to pass it as another parameter.

int output_n_and_val( int n, int val, int& biggestN ) {

    if( n > biggestN ) {
        cout << "(" << n << ") = " << val << endl;
        biggestN = n;
    }
    return val;
}

int recursiveFuncImpl( int n, int& biggestN ) {

    if( n == 1 ) {
        return output_n_and_val( n, -1, biggestN );
    }
    else if( n == 2 ) {
        return output_n_and_val( n, -1, biggestN );
    }
    else {
        int val =  2 * ( recursiveFuncImpl( n - 1, biggestN ) + recursiveFuncImpl( n - 2, biggestN ) );
        return output_n_and_val( n, val, biggestN );
    }
}

// Entrypoint function:
int recursiveFunc( int n ) {

    int biggestN = -1;
    return recursiveFuncImpl( n, biggestN );
}

int main()
{
    recursiveFunc( 10 );

    recursiveFunc( 5 );

    return 0;
}

The downside to this approach is that because of the n == 2 case-handling is encountered before n == 1 you'll never get the output (1) = -1 . Fixing that is an exercise left for the reader.

Answer 3

you should use an array to store values that you have computed, for example

const int N = 1000000;
int values[N]; // remember to memset to 0 first

int recursiveFunc(int n) {
    if(n < 0) return 0;
    if(values[n] != 0) return values[n];

    int val;    // value at nth sequence

    if (n == 1) {      // base case 1
        val = -1;
    }
    else if (n == 2) {  // base case 2
        val = -1;
    }
    else {      // recursive case
        val = 2 * (recursiveFunc(n - 1) + recursiveFunc(n - 2));
    }

    return values[n] = val;
}

int main() {
    memset(values, 0, sizeof(values));
    for (int i = 1; i < 10; i++) {

        std::cout << "(" << i << ") = " << recursiveFunc(i) << endl;
    }
    return 0;
}