Question

在我的程序中，将要求用户提供2种不同的选项。

我选择了选项2 ..iterative并键入任何值，然后导致输出。

但是，当我选择递归的第一个选项时，它不会输出任何值超过30的选项。意思是，如果键值为30，则会看到输出。＆amp;如果要键入40或50的值，将没有输出。

任何人都可以在您的编译器上进行测试吗？如果我的编译器有问题但是我的代码有问题，那就没关系。

#include<iostream>
using namespace std;

/* Fibonacci: recursive version */
int Fibonacci_R(int n)
{
    if (n <= 0) return 0;
    else if (n == 1) return 1;
    else return Fibonacci_R(n - 1) + Fibonacci_R(n - 2);
}

// iterative version
int Fibonacci_I(int n)
{
    int fib[] = { 0, 1, 1 };
    for (int i = 2; i <= n; i++)
    {
        fib[i % 3] = fib[(i - 1) % 3] + fib[(i - 2) % 3];
        cout << "fib(" << i << ") = " << fib[i % 3] << endl;
    }
    return fib[n % 3];
}

int main()
{
    int a, opt;
    cout << "Please choose the available option:\n";
    cout << "1)Recursive\n";
    cout << "2)Iterative\n";
    cin >> opt;
    if (opt == 1)
    {
        cout << "Please input value:\n";
        cin >> a;
        Fibonacci_R(a);
        cout << endl << "From recursive function" << endl;
        for (int i = 1; i <= a; ++i)
            cout << "fib(" << i << ") = " << Fibonacci_R(i) << endl;
        cout << endl;
    }
    else
    if (opt == 2)
    {
        cout << "Please input value:\n";
        cin >> a;
        Fibonacci_I(a);
    }
    system("pause");
    return 0;
}

Answer 1

在实施算法时，我喜欢在心理上评估算法，看看计算机在做什么。

  fib(30)
= fib(29)  +  fib(28)
= fib(28)  +  fib(27)  +  fib(27)  +  fib(26)
= fib(27)  +  fib(26)  +  fib(26)  +  fib(25)+  fib(26)+  fib(25) +  fib(25)+  fib(24)

我注意到这个算法看起来真的很低效。要计算fib（30），它需要2 ^ 30次计算！那是1073741824！

更糟糕的是，如果我将数字增加1，获得结果的时间/操作会加倍！

它可能永远以足够大的数量运行！（直到我入睡或我的CPU至少燃烧起来）

优化

但是，我注意到很多计算都是多余的。要计算fib(30)，必须计算fib(29)和fib(28)。要计算fib(29)，它会再次计算fib(28)。这么低效！

当我看到这些计算时，首先想到的是技术调用memoization。它缓存先前计算的结果并存储它们以供以后使用。

在这种情况下使用它会将计算次数减少到大约60次操作（？），但代价是使用更多内存。

示例：What is memoization and how can I use it in Python?

Answer 2

它没有卡住，只需要太长时间。这是因为递归计算的复杂性。我假设这个学校的例子是为了说明为什么递归方法在大多数时候都是劣等的，不应该使用。

假设您要计算Fibonacci_R（10）。您需要调用Fibonacci_R（8）和Fibonacci_R（9）。要计算Fibonacci_R（9），您需要调用Fibonacci_R（8）和Fibonacci_R（7）。这意味着你要两次调用Fibonacci_R（8）。如果继续你会发现你正在调用Fibonacci_R（7）三次 - 对于Fibonacci_R（8）调用两次而对Fibonacci_R调整为9次（9）...你将Fibonacci_R（6）调用五次 - 对于Fibonacci_R调用两次（8次））和Fibonacci_R（7）的三次......等等。当你开始不使用10而不是30时，这真的很难。如果你增加数量，这将使你的处理器燃烧。不要在家里试试或确保手边有灭火器。

顺便说一下。递归算法通常较差，不是因为复杂性，而是因为有限的内存堆栈用于在调用函数时存储变量和返回地址。

Answer 3

需要设置的条件 “int a” 所以，虽然如此，“Fibunacci_R”函数可以执行。所以; 我在调用“Fibunacci_R”的时候使用了“do / while”条件/循环并且它有效

#include <iostream>
using namespace std;

/* Fibonacci: recursive version */
int Fibonacci_R(int n)
{
    if (n <= 0) return 0;
    else if (n == 1) return 1;
    else return (Fibonacci_R(n - 1) + Fibonacci_R(n - 2));
}

// iterative version
int Fibonacci_I(int n)
{
    int fib[] = { 0, 1, 1 };
    for (int i = 2; i <= n; i++)
    {
        fib[i % 3] = fib[(i - 1) % 3] + fib[(i - 2) % 3];
        cout << "fib(" << i << ") = " << fib[i % 3] << endl;
    }
    return fib[n % 3];
}

int main() {
    int a, opt;
    cout << "Please choose the available option:\n";
    cout << "1)Recursive\n";
    cout << "2)Iterative\n";
    cin >> opt;
    if (opt == 1) {
        cout << "Please input value:\n";
        cin >> a;

        // Here
        do {
            cout << endl << "From recursive function" << endl;
            for (int i = 1; i <= a; ++i)
                cout << "fib(" << i << ") = " << Fibonacci_R(i) << endl;
            cout << endl;
            break;
        } while (Fibonacci_R(a));
    }
    else
    if (opt == 2)
    {
        cout << "Please input value:\n";
        cin >> a;
        Fibonacci_I(a);
    }
    system("pause");
    return 0;
}

计算大于45的整数输入只需要花费大量时间

C ++程序执行困难

3 个答案:

优化