返回未按预期退出递归方法 - C#

Question

这应该是相当基本的。 我觉得我错过了一些明显的东西，但我已经盯着这个看了一段时间了。 我有一个创建 Collat​​z 序列的递归方法（用作递归练习） 但是，一旦我的方法达到退出要求，我就会有一个“返回值”，然后跳回到方法内的递归调用。 如果有人能告诉我我错过了什么，我将不胜感激！ 谢谢，下面的代码！

public int sequenceCreator(int currentVal, int numOfSteps)
    {
        int nextVal;
        while (currentVal != 1)
        { 
            if (currentVal % 2 == 0)
            {
                nextVal = currentVal / 2;
                numOfSteps++;
            }
            else // (currentVal % 2 > 0)
            {
                nextVal = (currentVal * 3) + 1;
                numOfSteps++;
            }
            return sequenceCreator(nextVal, numOfSteps);
        }

        return numOfSteps;
    }

Answer 1

return 仅退出该特定方法调用。它不会在调用sequenceCreator() 的所有时间中止。

在这种情况下，应该没问题，因为它返回到这一行：

return sequenceCreator(nextVal, numOfSteps);

这又会再次返回给它的调用者，依此类推，直到您最终解决所有递归调用。

但我可能会写这样的方法，而不是：

public int sequenceCreator(int currentVal)
{
    if (currentVal == 1) return 1;

    if (currentVal % 2 == 0)
    {
        return 1 + sequenceCreator(currentVal / 2);
    }
    else // (currentVal % 2 > 0)
    {
        return 1 + sequenceCreator(currentVal * 3 + 1);
    }
}

该代码为相同的输入产生相同的结果，但代码更少，更易于理解，并且不需要在方法调用之间传递额外的状态。

为了好玩，我们可以使用三元运算符进一步减少代码（但我不建议使用此版本，因为 imo 可读性受到影响）：

public int sequenceCreator(int currentVal)
{
    if (currentVal == 1) return 1;
    return 1 + sequenceCreatetor(currentValue % 2 == 0? currentVal / 2 : currentVal * 3 + 1);
}

我展示这个版本是为了说明为什么使用递归。递归问题本质上是堆栈问题。对于每个递归解决方案，都存在一个仅依赖于传统方法的匹配解决方案，而是使用堆栈（递归解决方案只是“隐藏”堆栈，依赖于程序的调用堆栈）。但是，对于某些类型的问题，递归可以大幅减少解决它所需的代码量。所以我们也有相反的情况；如果您发现自己使用堆栈，可能有一种方法可以使用递归来大大简化问题。在这种情况下，方法体只有两行，如果我真的想要，我可以将其简化为一行代码。

您还需要了解这不会创建序列。在完全收敛的情况下，它只创建一个值。如果你真的想创建一个序列，你需要返回一个IEnumerable，最好使用yield关键字：

public IEnumerable<int> sequenceCreator(int currentVal)
{
    if (currentVal == 1) yield return 1;

    if (currentVal % 2 == 0)
    {
        yield return 1 + sequenceCreator(currentVal / 2);
    }
    else // (currentVal % 2 > 0)
    {
        yield return 1 + sequenceCreator(currentVal * 3 + 1);
    }
}

从逻辑上讲，我认为你在这里很安全，它会收敛。此方法的“最终”或基本情况是1 的输入。输入甚至减少到该基本情况的调用。输入为奇数的调用远离基本情况，但是下一个输入总是偶数，并且总是与我们之前尝试过的不同的偶数值。最终，我们希望得到 2 的幂，或者 3 乘以 2 的幂，即使它一直减少到 3 或 2，然后是 1，然后退出。

但是，我担心可能存在一些永远不会达到此状态的值，或者在它们可能之前溢出整数，或者在增加几次后减少到我们已经得到的偶数值尝试过，从而创造了一个永无止境的循环。

Answer 2

我认为不应该有任何循环。使用 if 条件代替 while。

如果 (currentVal != 1)

Answer 3

尽可能避免递归：

        int sequenceNumber = Convert.ToInt32(Console.ReadLine());
        List<int> list = new List<int>();

        while (sequenceNumber>=1)
        {
            if (sequenceNumber == 1)
            {
                Console.WriteLine(1);
                sequenceNumber = Convert.ToInt32(Console.ReadLine());
            }

            else if(sequenceNumber>1)
            {
                while (sequenceNumber>=1)
                {
                    if (sequenceNumber == 1)
                    {
                        list.Add(sequenceNumber);
                    }

                    else if (sequenceNumber % 2 == 0)
                    {
                        list.Add(sequenceNumber);
                        sequenceNumber = sequenceNumber / 2;

                    }
                    else if (sequenceNumber % 2 != 0)
                    {
                        list.Add(sequenceNumber);
                        sequenceNumber = sequenceNumber * 3 + 1;

                    }
                }

                list.ForEach(Console.WriteLine);
                foreach (int i in list)
                {
                    Console.Write(i + " ");

                }
            }

            sequenceNumber = Convert.ToInt32(Console.ReadLine());
        } 
    }