1列数的规则如下: 1、1、2、3、5、8、13、21、34. 求第30位数是多少， 用递归算法实现

一列数的规则如下: 1、1、2、3、5、8、13、21、34...... 求第30位数是多少， 用递归算法实现。
：public class MainClass 
    { 
        public static void Main()   
        { 
            Console.WriteLine(Foo(30)); 
        } 
        public static int Foo(int i) 
        { 
            if (i <= 0) 
                return 0; 
            else if(i > 0 && i <= 2) 
                return 1; 
            else return Foo(i -1) + Foo(i - 2); 
        } 
    } 


还是有点看不懂，求解释一下
------解决方案--------------------

static void Main(string[] args)

        {

            int count = Foo(30);

            Console.WriteLine(count); 

        }


        public static int Foo(int i)

        {

            if (i <= 0)

                return 0;

            else if (i > 0 && i <= 2)

                return 1;

            else

            {

                int a = Foo(i - 1);

                int b = Foo(i - 2);

                int count = a + b;

                return count;

            }

        } 

你这么修改一下 调试时单步走 看看Foo里面a、b、i还有最后count 观察他们的变动
最开始时Main函数里Foo(i)的i取个小一点的值 看下是个什么样流程

讲的话还真不知道怎么讲 你也可以画画流程图：
比如求a[4]的值就是下面这么一个流程：
①a[4]=a[3]+a[2],先求a[3]
②a[3]=a[2]+a[1]，求a[2]
③a[2]=a[1]+a[0]=2,求出a[2]
④由③，②则改为a[3]=2+a[1]，求a[1]=1,②a[3]=2+1=3
⑤由④，①为a[4]=3+a[2]，求a[2]
⑥a[2]=a[1]+a[0]=2
⑦由⑥，则⑤里a[4]=3+a[2]=3+2=5

------解决方案--------------------
如果搞懂这个数学函数公式，那么讲数学函数编程为c#函数应该不是问题。

可以“进阶”地考虑一下优化。可以在算法中对于中间结果进行保存，保证重复利用，这样再来比较一下计算速度就会发现质的变化：

private static List<long> fValues = new List<long>() { 1, 1 };


static long f(int x)

{

    if (x < 1)

        throw new InvalidOperationException();

    else if (x <= fValues.Count)

        return fValues[x - 1];

    else

    {

        var r = f(x - 1) + f(x - 2);

        fValues.Add(r);

        return r;

    }

}

简单输出结果可以写

for (var i = 1; i <= 80; i++)

    Console.WriteLine("i={0}, f={1}", i, f(i));

var rnd = new Random();

for (var j = 1; j <= 80; j++)

{

    var i = rnd.Next(80) + 1;

    Console.WriteLine("i={0}, f={1}", i, f(i));

}

这样可以看出运算速度！

不要做“过分聪明的”优化。你应该首先考虑将中间结果缓存起来，以后充分利用。如果这样做又可以保证算法与数学公式清晰地对应，又能保证效率较好，何乐而不为呢？

不要做过分聪明的优化。