C++ 递归-n个自然数之和

函数计算n个自然数之和

int solve(int n)
{
    if(n==0 or n==1)
    return n;
    int sum=0;

    sum=sum+n;
    solve(n-1);   // gives me wrong output

    return sum;
}

int solve(int n)
{
    if(n==0 or n==1)
    return n;
    int sum=0;

    sum=sum+solve(n-1);  // gives me correct output

    return sum;
}

---

当调用堆栈在两种情况下工作相同时，这两个函数的工作或输出有什么不同

这两个函数有很多共同之处

这些函数可以用负参数调用，因为参数类型是int。在这种情况下，您可以得到一个无意义的结果

累加数字总和的变量类型应大于int类型，以避免溢出

第一个函数总是在函数的第一次递归调用中返回传递参数的值

此声明

solve(n-1);   // gives me wrong output

if(n==0 or n==1)
return n;

无效，因为未使用返回值

由于此语句，第二个函数始终返回0或1（前提是传递了非负参数）

solve(n-1);   // gives me wrong output

if(n==0 or n==1)
return n;

因为在这个代码片段中

int sum=0;

sum=sum+solve(n-1);  // gives me correct output

未使用参数的当前值

好像有个打字错误，应该写出来

sum = n + solve(n-1);  // gives me correct output

该函数可以按照下面的演示程序中所示的方式进行声明和定义

#include <iostream>

unsigned long long sum( unsigned int n )
{
    return n == 0 ? 0 : n + sum( n - 1 );
}

int main()
{
    std::cout << sum( 100 ) << '\n';
    
    return 0;
}

函数中的return语句也可以编写为

return n < 2 ? n : n + sum( n - 1 );

返回n<2？n:n+和（n-1）；

为了减少递归调用的次数，可以通过以下方式重写函数

#include <iostream>

unsigned long long sum( unsigned int n )
{
    return n < 2 ? n : sum( n - 2 ) + n + n - 1;
}

int main()
{
    std::cout << sum( 100 ) << '\n';
    
    return 0;
}

#包括
无符号长和（无符号整数n）
{
返回n<2？n：和（n-2）+n+n-1；
}
int main（）
{
第一种方法中的std:：cout
solve
函数在程序中没有任何效果

int solve(int n)
{
    if(n==0 or n==1)
    return n;
    int sum=0;

    sum=sum+n;
    solve(n-1);   // has not any effect

    return sum;
}

在第二种方法中，返回值将始终为1，同时必须返回数字之和，计算数字之和的正确代码为：

int solve(int n)
{
    if (n == 0 || n == 1)
        return n;

    int sum = 0;

    sum = n + solve(n - 1);  // change 'sum' with 'n'

    return sum;
}

运行：

solve（5）；

输出：

5+4+3+2+1=15
看起来
solve
返回一些非常重要的东西，忽略它返回的东西不太正确，你认为呢？递归使用堆栈执行。在第一个解决方案中，你只做第一次迭代的求和，然后再次调用sum函数，并减小值，而不是u使用第二个函数，
solve（5）
returned
1
。这真的是正确的输出吗？