C#中的递归APS和CPS模式详解（转载）

　　这篇文章主要介绍了C#中的递归APS和CPS模式详解,本文讲解了累加器传递模式、CPS函数、CPS变换、CPS尾递归、尾递归与Continuation等内容,需要的朋友可以参考下

累加器传递模式(Accumulator passing style)

尾递归优化在于使堆栈可以不用保存上一次的返回地址/状态值，从而把递归函数当成一个普通的函数调用。

递归实际上是依赖上次的值，去求下次的值。 如果我们能把上次的值保存起来，在下次调用时传入，而不直接引用函数返回的值。 从而使堆栈释放，也就达到了尾递归优化的目的。

下面我们增加了一个acc的参数，它存储上次的值，在下次调用时传入。

    static int Accumulate(int acc,int n)
        {
            if(n==0)
                return acc;
            return Accumulate(acc*n,n-1);
        }

Accumulate递归时，我们仅需要使用最后一次的返回值即可。 调用如下：

　　var ac=Accumulate(1,20);

使用Lambda表达式实现尾递归阶乘：

    static int Accumulate(int n)
        {
            Func<int,int,int> acc=null;
            acc=(result,next)=>next==0?result:acc(result*next,n-1);
            return acc(1,n);
        }

 

后继传递模式（Continuation passing style）。

CPS函数

CPS全称Continuation passing style，中文一般译为后继传递模式。

    static int Time3(int x)
        {
            return x*3;
        }
        Console.WriteLine(Time3(5));

上面函数将输入值乘以3，我们平常基本上都会这样写。 其实我们还可以用返回函数的C#语法，构造嵌套方式，把函数的调用变成调用链times3(3)(5)。

这种方式在数学上或函数式编程中是比较直观的，正常的，但在指令式语言c#中却不是那么直观。

CPS中的后继(Continuation)一词指的是计算的剩余部分，类似times3(3)(5)红色这部分。
例如：表达式a*(b+c)的运算过程有多个计算步骤。可以c#写成下面函数来表示：

Console.WriteLine(Mult(a,Add(b,c)))

操作步骤如下：

1.b与c相加。
2.将结果乘以a。
3.输出结果。

执行1步时，后续操作是2,3。执行2步时，后续操作是3。 使用CPS模式来改造下times3函数：

　　static void Times3(int x,Action<int> continuation)
        {
            continuation(x*5);
        }            
    Console.WriteLine(Time3(5,(x)=>Console.WriteLine(x)));

我们增加了一个表示后继操作3的函数参数，调用时传递后续操作，这就是CPS函数。

CPS变换

知道了CPS函数后，再详细看下CPS变换。

    Console.WriteLine(Time3(5));
    //CPS 变换
    Time3CPS(3,x=>Console.WriteLine(x));

 

上面times3函数从直接调，到使用"后继传递操作"的过程就叫做CPS转换。
例如1：MAX函数的转换

static int Max(int n, int m)
{
    if (n > m)
        return n;
    else
        return m;
}
 Console.WriteLine(Max(3, 4));

 

我们把这max函数转换成CPS模式，需要下列步骤：
1：返回值修改成void
2：添加一个额外的类型参数 Action，T是原始返回类型。
3：使用后续操作表达式参数替代原来所有返回声明。

    static void Max(int x,int y,Action<int> k)
        {
            if(x>y)
            {
                k(x);
                return;
            }
            k(y);
        }

Max(3, 4, x => Console.WriteLine(x));

例如2：假如有3个函数Main、F、G，Main调用F、F调用G。

Console.WriteLine(F(1) + 1);
static int F(int n)
{
    return G(n + 1) + 1;
}
static int G(int n)
{
    return n + 1;
}

 

我们把F和G转换成CPS风格，和Max函数同样的转换步骤：

F(1, x => Console.WriteLine(x + 1));
static void F(int n, Action<int> k)
{
    G(n + 1, x => k(x + 1));
}
static void G(int n, Action<int> k)
{
    k(n + 1);
}

 CPS尾递归

这是传统的递归阶乘：

static int Factorial(int n)
{
    if (n == 0)
        return 1;
    else
        return n * Factorial(n - 1);
}

使用同样的步骤，把递归转换成CPS尾递归:

Factorial(5, x => Console.WriteLine(x));
static void Factorial(int n, Action<int> continuation)
{
    if (n == 0)
        continuation(1);
    else
        Factorial(n - 1, x => continuation(n * x));
}

 

“计算n的阶乘，并将结果传入continuation方法并返回”，也就是“计算n - 1的阶乘，并将结果与n相乘，再调用continuation方法”。为了实现“并将结果与n相乘，再调用continuation方法”这个逻辑，代码 又构造了一个匿名方法，再次传入Factorial方法。

　　总结

CPS模式是非常强大的，在很多方面都有使用，比如在编译器实现中CPS风格的解析器组合子、函数完成后回调。也可以说是把程序内部原本的控制操作，用CPS方法抽取出来暴露给程序员，例如文中的例子。

　　使用递归的技巧

　　 在使用递归时，要记住以下技巧：

　　1、确认递归能够停止。

　　　　检查子程序以确认其中含有一条非递归路径。通常这意味着子程序中含有一项判断，无须进一步的递归就可停止下来。

　　2、使用安全计数器防止出现无穷递归。

　　3、把递归限制在一个子程序中。
    　　 循环递归（A调用B，B调用C，C调用A）非常危险。对人脑而言理解一个递归已经够困难了，如果使用循环递归，那么就更难理解程序的逻辑了，对程序入口　　　  和出口的位置将更难把握，尤其是出口点，很容易造成想象不到的错误或者返回值。

　　4、留心栈空间。
    　　使用了递归以后，无法保证程序使用了多少栈空间，也很难预测程序在运行时的表现如何。不过，可以按照以下步骤来控制运行期间的表象。
    　　首先，使用安全计数器，在设置上限时，要考虑需要或者愿意为程序分配多少栈空间，应该把上限值设置的尽量低，防止堆栈溢出。

　　5、不要用递归去计算阶乘或斐波那契额数列。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　                                                                                                   转载地址：点击这里