C#获得斐波那契IEnumerable<；int>；用递归。。我希望它返回所有的数字，而不仅仅是最后一个 静态IEnumerable FibonacciByLength（int-length） { 如果（长度

如果

length

大于

1

，则需要

返回
FibonacciByLength（长度-1）中的每个数字
：

静态IEnumerable FibonacciByLength（int-length）
{
如果（长度==1）收益率为1；
else if（长度==2）
{
收益率1；
收益率1；
}
其他的
{
foreach（在FibonacciByLength中的var fib（长度-1））
收益率fib；
收益率返回FibonacciByLength（长度-1.Last（）+FibonacciByLength（长度-2.Last（）；
}
}

但我建议您不要使用递归来避免冗余计算：

static IEnumerable<int> FibonacciByLength(int length)
{
    if (length == 1) yield return 1;
    else if (length == 2)
    {
        yield return 1;
        yield return 1;
    }
    else
    {
        foreach (var fib in FibonacciByLength(length - 1))
            yield return fib;

        yield return FibonacciByLength(length - 1).Last() + FibonacciByLength(length - 2).Last();
    }
}

静态IEnumerable FibonacciByLength（int-length）
{
INTA=1；
int b=0；
对于（int i=1；i如果
length
大于
1
，您需要
返回
FibonacciByLength（length-1）中的每个数字：

静态IEnumerable FibonacciByLength（int-length）
{
如果（长度==1）收益率为1；
else if（长度==2）
{
收益率1；
收益率1；
}
其他的
{
foreach（在FibonacciByLength中的var fib（长度-1））
收益率fib；
收益率返回FibonacciByLength（长度-1.Last（）+FibonacciByLength（长度-2.Last（）；
}
}

但我建议您不要使用递归来避免冗余计算：

static IEnumerable<int> FibonacciByLength(int length)
{
    if (length == 1) yield return 1;
    else if (length == 2)
    {
        yield return 1;
        yield return 1;
    }
    else
    {
        foreach (var fib in FibonacciByLength(length - 1))
            yield return fib;

        yield return FibonacciByLength(length - 1).Last() + FibonacciByLength(length - 2).Last();
    }
}

静态IEnumerable FibonacciByLength（int-length）
{
INTA=1；
int b=0；
对于（inti=1；i，如果您不受传递到方法中的参数的限制，我建议如下

static IEnumerable<int> FibonacciByLength(int length)
{
    int a = 1;
    int b = 0;

    for (int i = 1; i <= length; i++)
    {
        int c = a + b;

        a = b;
        b = c;

        yield return c;
    }
}

这样做的原因是可以避免不必要的调用。使用此方法，如果要计算Fibonacci序列的前10个值，它将只调用FibonacciByLength 10次。在每次调用FibonacciByLength时，您都会传入计算下一个值所需的值，因此您不必重新计算它

使用Arturo建议的方法，您将调用该方法2089次，这是因为有多个调用，如FibonacciByLength（length-1）.Last（），这需要重新计算整个序列，直到传入的长度，才能得到最后一个值。如果您只能传入长度值，那么您没有任何其他选项，您必须接受需要进行的调用的指数数量。
如果您不受传入方法的参数的限制，我建议如下

static IEnumerable<int> FibonacciByLength(int length)
{
    int a = 1;
    int b = 0;

    for (int i = 1; i <= length; i++)
    {
        int c = a + b;

        a = b;
        b = c;

        yield return c;
    }
}

这样做的原因是可以避免不必要的调用。使用此方法，如果要计算Fibonacci序列的前10个值，它将只调用FibonacciByLength 10次。在每次调用FibonacciByLength时，您都会传入计算下一个值所需的值，因此您不必重新计算它

使用Arturo建议的方法，您将调用该方法2089次，这是因为有多个调用，如FibonacciByLength（length-1）.Last（）这需要重新计算整个序列直到达到最后一个值的长度。如果你只能传递长度值，那么你就没有其他选项了，你必须使用需要调用的指数数。
你可以考虑使用<代码>列表< /C>。/代码>你的Fibonacci数Fibonacci就像教科书上的一个算法示例，使用朴素递归非常糟糕。你应该使用迭代方法来解决这个问题。它的复杂性是线性的，而不是指数的，代码将非常简单。谢谢你的回答，Ian，请记住另外，
IEnumerable
不太适合递归。每次递归调用都必须使用
foreach
，这每次都会创建一个新的枚举器对象。（它毕竟称为迭代器。'iterator'='iterative'）我将搜索一些关于迭代器的东西，它对我来说是新的，但是非常有趣。谢谢。你可以考虑使用<代码>列表< /C>。然后你可以简单地说“代码>添加< /代码>。你的斐波那契数Fibonacci就像是一个使用天真递归的算法的教科书例子。你应该使用一个迭代的方法来解决。解决这个问题。它的复杂性是线性的，而不是指数的，代码也会非常简单。谢谢你的回答，伊恩，请记住。另外，
IEnumerable
不适合递归。你必须在每次递归调用中使用
foreach
，这会每隔一段时间创建一个新的枚举器对象ime。（它毕竟称为迭代器。'iterator'='iterative'）我将搜索一些关于迭代器的内容，这对我来说是新的，但非常有趣。非常感谢。第一个解决方案是使用递归和枚举。非常感谢您提供如此快速和完整的答案，它帮助很大。第二个方法可以简化为：
静态IEnumerable FibonacciByLength（int length）{int a=1，b=0；例如（inti=0；i
第一个解决方案是使用递归和枚举。非常感谢您提供如此快速和完整的答案，它帮助很大。第二个方法可以简化为：
静态IEnumerable FibonacciByLength（intlength）{inta=1，b=0；对于（inti=0；i
它的工作原理非常棒。我也在考虑它，但它对我来说是新的，有点难理解，将在它上面做更多的工作，并将尝试编写代码来计算fibonacci数，该数低于int maxValues。不难修改，以返回最大限度的值。您将删除valuesCalcualtedSoFar和您的所有使用可以重命名maxVa
    var values = FibonacciByLength(10).ToList();