为什么我的函数在完成（递归）后不再次调用自身？

Question

I currently finished my code. but for some reason my recursive call at the end isn't being triggered? Is there some sort of special code I am missing from this by chance?

int max(int arr[], int start, int end) {    
        int greatest = arr[start];
        if(start < end)
        {

        if(greatest<arr[start])
        {
            greatest = arr[start];
        }
        start++;
        max(arr, start, end); // Doesn't seem to be triggering since it only returns 8
        }   
        return greatest;
}       

int main()
{
     int greatest;
     int arr[10] = {8,1,2,3,4,5,6,7,8,9};
     int start = 0;
     int end = 10;
     greatest=max(arr, start, end);

     pintf("%d\n", greatest);

}

Answer 1

Only the first call to max - the one located in main - actually assigns its return value to anything. The values returned by the recursive calls are immediately lost; the work they do is meaningless to the end result. You need to assign the result of the recursive call to max to greatest .

Remember that each recursive call opens up a new scope, each with its own version of the greatest variable. The assignments within each recursive call only modify their version of the variable, not the one from the enclosing scope; this means that the version from the very first call is never set to anything after taking the value of arr[0] ; and that's the version whose value is returned to main when the outermost call resumes, regardless of the work done in between by the recursive calls.

You also have an unrelated error, which is that you recurse into another call to max (and assign to greatest within that call) before checking whether you've reached the end of the array, which will overflow beyond the end of the array and overwrite the final result with whatever is found there (as Paul points out, you also assign to greatest before making the comparison against the current value, so the comparison is essentially meaningless). You need to move everything inside the checks to make sure this doesn't occur.

Answer 2

I believe the recursive call is being triggered, but isn't doing what you want. you initialize greatest to arr[start] (in this case 8), and never assign anything else to it, so of course your function is returning 8. Instead, it seems like your function should return arr[start] if start >= end, and otherwise should return either arr[start] or max(arr, start+1, end), whichever is larger.

Answer 3

Your algorithm is a little messed up. For instance, greatest<arr[start] will never be true, because you just set greatest = arr[start] . Here's a commented working algorithm:

#include <stdio.h>

int max(int arr[], int start, int end)
{
    if ( start >= end ) {

        /*  Shouldn't get here, but return 0 if we do  */

        return 0;
    }
    else if ( end - start == 1 ) {

        /*  Only one element, so it's the maximum by definiton  */

        return arr[start];
    }
    else {

        /*  Find the maximum of the rest of the list...  */

        int greatest = max(arr, start + 1, end);

        /*  ...and return the greater of it, and the first element  */

        return arr[start] > greatest ? arr[start] : greatest;
    }
}

int main(void)
{
    int arr[] = { 8, 1, 2, 3, 12, 5, 6, 7, 8, 9 };
    int start = 0;
    int end = 10;
    int greatest = max(arr, start, end);

    printf("%d\n", greatest);
}

with output:

paul@thoth:~/src/sandbox$ ./max
12
paul@thoth:~/src/sandbox$ 

Let's go through it with a simple list, {1, 5, 3}. Each indentation level represents one of your recursive function calls. Every time we see max() , we go up a level - every time we see return , we go back a level.

In main(), int greatest = max(list, 0, 3)

    In call 1: (end - start == 1) is false
    In call 1: int greatest = max(list, 1, 3)

        In call 2: (end - start == 1) is false
        In call 2: int greatest = max(list, 2, 3)

             In call 3: (end - start == 1) is true
             In call 3: return arr[2], which is 3 

        Back in call 2: greatest now equals 3
        Back in call 2: arr[1] == 5, which is > 3, so return arr[1], which is 5

    Back in call 1: greatest now equals 5
    Back in call 1: arr[0] == 1, which is not > 5, so return greatest, which is 5

Back in main(), greatest now equals 5

Remember, every time you see int greatest , that's a different variable that's being created. They all have the same name, but since they're all in separate scopes, they're still all different. The int greatest in call 2, for instance, is completely separate from the int greatest in call 1, just as the int greatest in call 1 is completely separate from the int greatest in main() .

EDIT: From the comments, if you want the index of the maximum value as well, this'll do it:

#include <stdio.h>

int max_index(int arr[], int start, int end)
{
    if ( start >= end ) {
        return 0;
    }
    else if ( end - start == 1 ) {
        return start;
    }
    else {
        int greatest = max_index(arr, start + 1, end);
        return arr[start] > arr[greatest] ? start : greatest;
    }
}

int max(int arr[], int start, int end)
{
    if ( start >= end ) {

        /*  Shouldn't get here, but return 0 if we do  */

        return 0;
    }
    else if ( end - start == 1 ) {

        /*  Only one element, so it's the maximum by definiton  */

        return arr[start];
    }
    else {

        /*  Find the maximum of the rest of the list...  */

        int greatest = max(arr, start + 1, end);

        /*  ...and return the greater of it, and the first element  */

        return arr[start] > greatest ? arr[start] : greatest;
    }
}

int main(void)
{
    int arr[] = { 8, 1, 2, 3, 12, 5, 6, 7, 8, 9 };
    int start = 0;
    int end = 10;
    int greatest = max(arr, start, end);
    int index = max_index(arr, start, end);

    printf("Greatest value is %d at index %d\n", greatest, index);
}

output:

paul@thoth:~/src/sandbox$ ./max
Greatest value is 12 at index 4
paul@thoth:~/src/sandbox$