Question

我有以下代码如下。它接受输入并逐行打印以解决河内问题。我想要做的就是在每一行中打印step1，step2等，从1开始直到步骤结束，如下例所示：

输入磁盘数：3
步骤1：1 - ＆gt; 2将一个圆盘从原始栓钉移动到额外的栓钉上步骤2：1 - ＆gt; 3将一个磁盘从原始挂钉移动到目标挂钉
步骤3：2 - ＆gt; 3将一个磁盘从额外的挂钩移动到目标挂钩

  #include <iostream>
int count=1;
     void ToH(int dskToMv, int cLocation, string orpeg, int tmpLocation, string expeg, int fLocation, string depeg)
    {
         if( dskToMv != 0 ) 
        {
count++;
            ToH( dskToMv-1, cLocation, orpeg, fLocation, depeg, tmpLocation, expeg);
            cout<<"Step "<<count<<": Move one disk from the "<< orpeg << " to the " << depeg
                << " " << cLocation << " -> " << fLocation << endl;
            ToH( dskToMv-1, tmpLocation, expeg, cLocation, orpeg, fLocation, depeg);
        }
    }

    int main()
    {
        int c;
        cout << "Enter the number of disks: ";
        cin >> c;
        ToH(c, 1, "original peg ", 2, "extra peg", 3, "destination peg");
    }

Answer 1

在递归中，当你需要“保持”每次迭代的跟踪时，有几种方法：

原始全局变量 - 这些变量只允许保留单个状态。如果递归分支等，它可能不起作用，因为一个分支将覆盖另一个分支正在使用的值。为了简单地存储像计数这样的东西，这些往往效果很好。
将参数传递给函数 - 函数的参数存储在堆栈中。当调用该函数时，它们被推送，因此对于每次递归，我们最终得到每次迭代调用的参数值“堆栈”。这适用于递归，因为不同的分支不会破坏其他值（弹出发生在函数调用的末尾，只弹出调用推送的值）。
使用复杂的全局数据结构。这些基本上将参数存储在函数调用之外，并允许发生更复杂的事情（例如，使用队列而不是堆栈）但需要更多工作。因为它们在函数外部，所以如果需要，可以由其他分支查看。

您需要做的就是声明一个全局int，然后在函数调用中递增它。每次调用该函数时，该值都会递增，从而计算函数调用的次数。由于它只是递增，我们没有分支问题（因为每个分支都会做同样的事情，因此无法区分）。

int count = 0;
 void ToH(int dskToMv, int cLocation, string orpeg, int tmpLocation, string expeg, int fLocation, string depeg)
{
   count++;
     if( dskToMv != 0 ) 
    {
        ToH( dskToMv-1, cLocation, orpeg, fLocation, depeg, tmpLocation, expeg);
        cout<<" Move one disk from the "<< orpeg << " to the " << depeg
            << " " << cLocation << " -> " << fLocation << " - " << count << endl;
        ToH( dskToMv-1, tmpLocation, expeg, cLocation, orpeg, fLocation, depeg);
    }
}

或者，如果您想允许回溯并因此实际计算“级别”，您可以使用参数：

 void ToH(int dskToMv, int cLocation, string orpeg, int tmpLocation, string expeg, int fLocation, string depeg, int count = 0)
{
     if( dskToMv != 0 ) 
    {
        ToH( dskToMv-1, cLocation, orpeg, fLocation, depeg, tmpLocation, expeg, count + 1);
        cout<<" Move one disk from the "<< orpeg << " to the " << depeg
            << " " << cLocation << " -> " << fLocation << " - " << count << endl;
        ToH( dskToMv-1, tmpLocation, expeg, cLocation, orpeg, fLocation, depeg, count + 1);
    }
}

并非所有方法都相同。当您学会将递归视为对大型分支数据结构的某种“搜索”时，更容易思考这些事情。当你只使用相当于迭代的简单递归时，这些不同的方法之间没有太大的区别。

Answer 2

您可以尝试使用静态变量。每次（递归地）调用函数时递增此变量。

#include <iostream>

 void ToH(int dskToMv, int cLocation, string orpeg, int tmpLocation, string expeg, int fLocation, string depeg)
{
    static int count=0 
    if( dskToMv != 0 ) 
    {
        count++;
        ToH( dskToMv-1, cLocation, orpeg, fLocation, depeg, tmpLocation, expeg);
        cout<<"Step "<<count<<": Move one disk from the "<< orpeg << " to the " << depeg
            << " " << cLocation << " -> " << fLocation << endl;
        ToH( dskToMv-1, tmpLocation, expeg, cLocation, orpeg, fLocation, depeg);
    }
}

int main()
{
    int c;
    cout << "Enter the number of disks: ";
    cin >> c;
    ToH(c, 1, "original peg ", 2, "extra peg", 3, "destination peg");
}

希望这有帮助

如何计算递归函数的调用（递增1）| C ++

2 个答案: