C中的递归-数组的最大元素

此程序使用递归方法返回数组的最大元素：

#include <stdio.h>

int maiorVetor(int *V, int N) {
    int maior;
    if (N == 1)
        return V[0];
    else {
        maior = maiorVetor(V, N - 1);
        if (maior > V[N - 1])
            return maior;
        else
            return V[N - 1];
    }
}

int main () {
    int A[10] = { 12, 65, 14, 38, 33, 11, 20, 23, 21, 43 };

    printf("%d", maiorVetor(A, 10));
    return 0;
}

#包括
内特迈奥维托（内特*V，内特N）{
国际货币基金组织；
如果（N==1）
返回V[0]；
否则{
maior=Maiorvettor（V，N-1）；
如果（maior>V[N-1]）
返回主界面；
其他的
返回V[N-1]；
}
}
int main（）{
INTA[10]={12,65,14,38,33,11,20,23,21,43}；
printf（“%d”，maiorVetor（A，10））；
返回0；
}

---

有人能一步一步地给我解释一下这个程序是如何工作的吗？因为在我看来，当程序到达

maior=maiorVetor（V，N-1）时它不会继续，只是重新启动，直到
N
=0。但事实上，这个程序是有效的，它确实给了我一个真正的解决方案。我不明白这种递归是如何工作的。
正如前面所评论的，更好地理解代码流的方法是使用调试器（可能是在线调试器，如下面的参考链接3所示）来理解它

简而言之，递归调用maiorVetor（V，N-1）函数，直到它达到递归的退出条件i，e，直到N==1。在这些步骤中，它将按降序排列整数数组A，并返回最大的数字，即A[0]

如果您想了解递归如何工作以及它如何使用堆栈，请参考以下链接：




我将画一个递归树，然后尝试解释它

我正在修改并减小程序中数组的大小，以便更容易解释-

#include <stdio.h>
int maiorVetor(int A, int N) {
    int maior;
    if(N == 1)
        return A[0];
    else {
        maior = maiorVetor(A, N-1);
        if(maior > A[N-1])
            return maior;
        else
            return A[N-1];
    }
}
int main () {
    int A[4] = {12, 65, 14, 38};

    printf("%d", maiorVetor(A, 4));

return 0;

}

步骤2）（参考递归树图）

步骤3）（参考递归树图）

步骤4）（参考递归树图）

步骤5）（参考递归树图）

步骤6）（参考递归树图）

步骤7）（参考递归树图）

步骤8）（参考递归树图）

所以，您的输出是

65

你认为当它到达
maior=maiorVetor（V，N-1）
时会发生什么？它调用
maiorVetor
，对吗？当
maiorVetor
返回时，会发生什么？下一行，对吗
if（maior>V[N-1]）
只使用3个整数的数组，这些整数可以相对容易地在纸上或头上计算出来。使用调试器逐步检查代码并查看发生了什么。尝试将maior初始化为零：maior=0了解程序的工作原理后，可以解释程序的工作原理。对更常见的“要理解递归，首先必须理解递归”稍作解释。但当maiorVetor返回数组时，数组只是V[0]，因为它已递减N倍，对吗？当它转到下一行时，数组是否有N=0？
int maiorVetor(int A, int 3) {
    int maior;
    if(N == 1) // here 3!=1
        return A[0];
    else {
        maior = maiorVetor(A, N-1); //this is where recursion happens.

                                    //So,maior=maiorVector(A,3-1)=maiorVector(A,2)

                                    //Now here, we again call the maiorVector function 
                                    //with value maiorVector(A,2)

        /*So, for now we leave original function func. maiorVector(A,3) just at this 
        line, i.e , just before the if statement.
        We'll touch this if statement and consequent statements again in Step 7.*/  

       if(maior > A[N-1])
            return maior;
        else
            return A[N-1];
    }
}

int maiorVetor(int A, int 2) {
    int maior;
    if(N == 1) // here 2!=1
        return A[0];
    else {
        maior = maiorVetor(A, N-1); //this is where recursion happens.

                                    //So,maior=maiorVector(A,2-1)=maiorVector(A,1)

                                    //Now here, we again call the maiorVector function 
                                    //with value maiorVector(A,1)

        /*So, for now we leave original function func. maiorVector(A,2) just at this 
        line, i.e , just before the if statement.
        We'll touch this if statement and consequent statements again in Step 6.*/  

       if(maior > A[N-1])
            return maior;
        else
            return A[N-1];
    }
}

int maiorVetor(int A, int 1) {
    int maior;
    if(N == 1) // YES,HERE 1==1.SO WE REUTRN A[0]=12.
       return A[0]; //THE LOOP IS TERMINATED AND WE EXIT FROM mainVector(int A,int 1).
    else {
        maior = maiorVetor(A, N-1);           
       if(maior > A[N-1])
            return maior;
        else
            return A[N-1];
    }
}

/*From this step, we start coming out of the recursion. That, according to the 
Recursive tree diagram, we start moving in the reverse/upward direction.*/

    /*The value returned in step 4 from maiorVector(A,1)=12 is stored in the variable 
    maior in the first statement of else block.*/ 

    int maiorVetor(int A, int 2) {
        int maior;
        if(N == 1) // here 2!=1
            return A[0];
        else {
            maior = maiorVetor(A, N-1); // =maiorVector(A,2-1)=maiorVector(A,1)=12               

           if(maior > A[N-1])
                return maior;
            else
                return A[N-1];
        }
    }

//as told in Step 3, we had to come back in the maiorVector(A,2) in step 6.
int maiorVetor(int A, int 2) {
        int maior;
        if(N == 1) // here 2!=1
            return A[0];
        else {
            maior = maiorVetor(A, N-1); // =maiorVector(A,2-1)=maiorVector(A,1)=12               

           if(maior > A[N-1]) //if(12>A[2-1])-->if(12>A[1])-->if(12>65), which is 
                              //false
                return maior;
            else
                return A[N-1]; /*Since else part is true, we will return 65.

                               Also, this 65 is returned as the value for maior in the 
                               fucntion maiorVector(A,3) in step 7*/
        }
    }

//as told in Step 2, we had to come back in the maiorVector(A,3) in step 7.
int maiorVetor(int A, int 3) {
        int maior;
        if(N == 1) // here 3!=1
            return A[0];
        else {
            maior = maiorVetor(A, N-1); // =maiorVector(A,3-1)=maiorVector(A,2)=65               

           if(maior > A[N-1]) //if(65>A[3-1])-->if(65>A[2])-->if(65>14), which is 
                              //true. So return 65.


                return maior; /*Also, this 65 acts as the value for maior for the 
                               fucntion maiorVector(A,4)*/
            else
                return A[N-1]; //false, so not executed.
        }
    }

//as told in Step 1, we had to come back in the maiorVector(A,4) in step 8.
int maiorVetor(int A, int 4) {
        int maior;
        if(N == 1) // here 4!=1
            return A[0];
        else {
            maior = maiorVetor(A, N-1); // =maiorVector(A,4-1)=maiorVector(A,3)=65               

           if(maior > A[N-1]) //if(65>A[4-1])-->if(65>A[3])-->if(12>14), which is 
                              //true. So return 65.


                return maior; /*Now,this value 65 is returned and printed through the 
                              printf("%d",mainVector(A,4)); statement in the main 
                              function*/
            else
                return A[N-1]; //false, so not executed.
        }
    }

65