递归转非递归(学习笔记)

在网上逛的时候发现一篇好文 递归转非递归 ，阅读完，觉得有启发，把重点记录下来，另外作者是用ISO C++语言描述的，我在测试的时候把它改成C#2.0的拉：

为什么要递归转非递归:
因为每一次的递归调用都需要压栈占用内存，效率不高．

递归转非递归的两种方法：
下面以求n的阶乘来说明
先给出一般的递归方法：

递归求阶乘
 1        /**//// <summary>
 2        /// 递归求阶乘
 3        /// </summary>
 4        private int Factorial(int n)
 5        {
 6            if (n > 1)
 7            {
 8                return n * Factorial(n - 1);
 9            }
10            else if (n == 1)
11            {
12                return 1;
13            }
14            else
15            {
16                throw new ArgumentException("Argument Error");
17            }
18        }

非递归方法一：循环法，前提是，待解决问题必须能够分解出可循环规律方可
而n! = n! = n*(n-1)*(n-2)*....*1;从循环的角度理解就是：n!表示执行n次循环计算一个增量k，初始k=1和结果t=1;每次t乘以k++的值.从而可以得到：

循环求阶乘
 1        /**//// <summary>
 2        /// 循环求阶乘
 3        /// </summary>
 4        private int FactorialByLoop(int n)
 5        {
 6            int k = 1;
 7            int t = 1;
 8            while (k <= n)
 9            {
10                t *= k;
11                k++;
12            }
13
14            return t;
15        }

非递归方法二：自定义堆栈法，目的是为不能分析出来循环的递归操作提供开销可控的方法.如：

自定义堆栈求阶乘
 1        /**//// <summary>
 2        /// 自定义堆栈求阶乘
 3        /// </summary>
 4        private int FactorialByStack(int n)
 5        {
 6            Stack<int> s = new Stack<int>();
 7            int t = 1;
 8            int temp;
 9            s.Push(n);
10            while ((temp = s.Peek()) != 1)
11            {
12                t *= s.Peek();
13                s.Pop();
14                s.Push(temp - 1);
15            }
16            return t;
17        }

说明：以上代码在Visual Studio 2005 Express中测试通过．