递归算法详细分析->C
C通过运行时堆栈支持递归函数的实现。递归函数就是直接或间接调用自身的函数。
许多教科书都把计算机阶乘和菲波那契数列用来说明递归，非常不幸我们可爱的著名的老潭老师的《C语言程序设计》一书中就是从阶乘的计算开始的函数递归。导致读过这本经书的同学们，看到阶乘计算第一个想法就是递归。但是在阶乘的计算里，递归并没有提供任何优越之处。在菲波那契数列中，它的效率更是低的非常恐怖。
这里有一个简单的程序，可用于说明递归。程序的目的是把一个整数从二进制形式转换为可打印的字符形式。例如：给出一个值4267，我们需要依次产生字符‘4’，‘2’，‘6’，和‘7’。就如在printf函数中使用了%d格式码，它就会执行类似处理。
我们采用的策略是把这个值反复除以10，并打印各个余数。例如，4267除10的余数是7，但是我们不能直接打印这个余数。我们需要打印的是机器字符集中表示数字‘7’的值。在ASCII码中，字符‘7’的值是55，所以我们需要在余数上加上48来获得正确的字符，但是，使用字符常量而不是整型常量可以提高程序的可移植性。‘0’的ASCII码是48，所以我们用余数加上‘0’，所以有下面的关系：
‘0’+ 0 =‘0’
‘0’+ 1 =‘1’
‘0’+ 2 =‘2’
...
从这些关系中，我们很容易看出在余数上加上‘0’就可以产生对应字符的代码。接着就打印出余数。下一步再取商的值，4267/10等于426。然后用这个值重复上述步骤。
这种处理方法存在的唯一问题是它产生的数字次序正好相反，它们是逆向打印的。所以在我们的程序中使用递归来修正这个问题。
我们这个程序中的函数是递归性质的,因为它包含了一个对自身的调用。乍一看，函数似乎永远不会终止。当函数调用时，它将调用自身，第2次调用还将调用自身，以此类推，似乎永远调用下去。这也是我们在刚接触递归时最想不明白的事情。但是，事实上并不会出现这种情况。
这个程序的递归实现了某种类型的螺旋状while循环。while循环在循环体每次执行时必须取得某种进展，逐步迫近循环终止条件。递归函数也是如此，它在每次递归调用后必须越来越接近某种限制条件。当递归函数符合这个限制条件时，它便不在调用自身。
在程序中，递归函数的限制条件就是变量quotient为零。在每次递归调用之前，我们都把quotient除以10，所以每递归调用一次，它的值就越来越接近零。当它最终变成零时，递归便告终止。
/*接受一个整型值（无符号0，把它转换为字符并打印它，前导零被删除*/
#include <stdio.h>
int binary_to_ascii( unsigned int value)
{
unsigned int quotient;
quotient = value / 10;
if( quotient != 0)
binary_to_ascii( quotient);
putchar ( value % 10 + '0' );
}
递归是如何帮助我们以正确的顺序打印这些字符呢？下面是这个函数的工作流程。
1. 将参数值除以10
2. 如果quotient的值为非零，调用binary-to-ascii打印quotient当前值的各位数字
3. 接着，打印步骤1中除法运算的余数
注意在第2个步骤中，我们需要打印的是quotient当前值的各位数字。我们所面临的问题和最初的问题完全相同，只是变量quotient的值变小了。我们用刚刚编写的函数（把整数转换为各个数字字符并打印出来）来解决这个问题。由于quotient的值越来越小，所以递归最终会终止。
一旦你理解了递归，阅读递归函数最容易的方法不是纠缠于它的执行过程，而是相信递归函数会顺利完成它的任务。如果你的每个步骤正确无误，你的限制条件设置正确，并且每次调用之后更接近限制条件，递归函数总是能正确的完成任务。
但是，为了理解递归的工作原理，你需要追踪递归调用的执行过程，所以让我们来进行这项工作。追踪一个递归函数的执行过程的关键是理解函数中所声明的变量是如何存储的。当函数被调用时，它的变量的空间是创建于运行时堆栈上的。以前调用的函数的变量扔保留在堆栈上，但他们被新函数的变量所掩盖，因此是不能被访问的。
当递归函数调用自身时，情况于是如此。每进行一次新的调用，都将创建一批变量，他们将掩盖递归函数前一次调用所创建的变量。当我追踪一个递归函数的执行过程时，必须把分数不同次调用的变量区分开来，以避免混淆。
程序中的函数有两个变量：参数value和局部变量quotient。下面的一些图显示了堆栈的状态，当前可以访问的变量位于栈顶。所有其他调用的变量饰以灰色的阴影，表示他们不能被当前正在执行的函数访问。
假定我们以4267这个值调用递归函数。当函数刚开始执行时，堆栈的内容如下图所示：
执行除法之后，堆栈的内容如下：
接着，if语句判断出quotient的值非零，所以对该函数执行递归调用。当这个函数第二次被调用之初，堆栈的内容如下：
堆栈上创建了一批新的变量，隐藏了前面的那批变量，除非当前这次递归调用返回，否则他们是不能被访问的。再次执行除法运算之后，堆栈的内容如下：
quotient的值现在为42，仍然非零，所以需要继续执行递归调用，并再创建一批变量。在执行完这次调用的出发运算之后，堆栈的内容如下：
此时，quotient的值还是非零，仍然需要执行递归调用。在执行除法运算之后，堆栈的内容如下：
不算递归调用语句本身，到目前为止所执行的语句只是除法运算以及对quotient的值进行测试。由于递归调用这些语句重复执行，所以它的效果类似循环：当quotient的值非零时，把它的值作为初始值重新开始循环。但是，递归调用将会保存一些信息（这点与循环不同），也就好是保存在堆栈中的变量值。这些信息很快就会变得非常重要。
现在quotient的值变成了零，递归函数便不再调用自身，而是开始打印输出。然后函数返回，并开始销毁堆栈上的变量值。
每次调用putchar得到变量value的最后一个数字，方法是对value进行模10取余运算，其结果是一个0到9之间的整数。把它与字符常量‘0’相加，其结果便是对应于这个数字的ASCII字符，然后把这个字符打印出来。
接着函数返回，它的变量从堆栈中销毁。接着，递归函数的前一次调用重新继续执行，她所使用的是自己的变量，他们现在位于堆栈的顶部。因为它的value值是42，所以调用putchar后打印出来的数字是2。
接着递归函数的这次调用也返回，它的变量也被销毁，此时位于堆栈顶部的是递归函数再前一次调用的变量。递归调用从这个位置继续执行，这次打印的数字是6。在这次调用返回之前，堆栈的内容如下：
现在我们已经展开了整个递归过程，并回到该函数最初的调用。这次调用打印出数字7，也就是它的value参数除10的余数。
然后，这个递归函数就彻底返回到其他函数调用它的地点。
如果你把打印出来的字符一个接一个排在一起，出现在打印机或屏幕上，你将看到正确的值：4267
汉诺塔问题递归算法分析：
一个庙里有三个柱子，第一个有64个盘子，从上往下盘子越来越大。要求庙里的老和尚把这64个盘子全部移动到第三个柱子上。移动的时候始终只能小盘子压着大盘子。而且每次只能移动一个。
1、此时老和尚（后面我们叫他第一个和尚）觉得很难，所以他想：要是有一个人能把前63个盘子先移动到第二个柱子上，我再把最后一个盘子直接移动到第三个柱子，再让那个人把刚才的前63个盘子从第二个柱子上移动到第三个柱子上，我的任务就完成了，简单。所以他找了比他年轻的和尚（后面我们叫他第二个和尚），命令：
① 你丫把前63个盘子移动到第二柱子上
② 然后我自己把第64个盘子移动到第三个柱子上后
③ 你把前63个盘子移动到第三柱子上
2、第二个和尚接了任务，也觉得很难，所以他也和第一个和尚一样想：要是有一个人能把前62个盘子先移动到第三个柱子上，我再把最后一个盘子直接移动到第二个柱子，再让那个人把刚才的前62个盘子从第三个柱子上移动到第三个柱子上，我的任务就完成了，简单。所以他也找了比他年轻的和尚（后面我们叫他第三和尚），命令：
① 你把前62个盘子移动到第三柱子上
② 然后我自己把第63个盘子移动到第二个柱子上后
③ 你把前62个盘子移动到第二柱子上
3、第三个和尚接了任务，又把移动前61个盘子的任务依葫芦话瓢的交给了第四个和尚，等等递推下去，直到把任务交给了第64个和尚为止（估计第64个和尚很郁闷，没机会也命令下别人，因为到他这里盘子已经只有一个了）。
4、到此任务下交完成，到各司其职完成的时候了。完成回推了：
第64个和尚移动第1个盘子，把它移开，然后第63个和尚移动他给自己分配的第2个盘子。
第64个和尚再把第1个盘子移动到第2个盘子上。到这里第64个和尚的任务完成，第63个和尚完成了第62个和尚交给他的任务的第一步。
从上面可以看出，只有第64个和尚的任务完成了，第63个和尚的任务才能完成，只有第2个和尚----第64个和尚的任务完成后，第1个和尚的任务才能完成。这是一个典型的递归问题。 现在我们以有3个盘子来分析：
第1个和尚命令：
① 第2个和尚你先把第一柱子前2个盘子移动到第二柱子。（借助第三个柱子）
② 第1个和尚我自己把第一柱子最后的盘子移动到第三柱子。
③ 第2个和尚你把前2个盘子从第二柱子移动到第三柱子。
很显然，第二步很容易实现（哎，人总是自私地，把简单留给自己，困难的给别人）。
其中第一步，第2个和尚他有2个盘子，他就命令：
① 第3个和尚你把第一柱子第1个盘子移动到第三柱子。（借助第二柱子）
② 第2个和尚我自己把第一柱子第2个盘子移动到第二柱子上。
③ 第3个和尚你把第1个盘子从第三柱子移动到第二柱子。
同样，第二步很容易实现，但第3个和尚他只需要移动1个盘子，所以他也不用在下派任务了。（注意：这就是停止递归的条件，也叫边界值）
第三步可以分解为，第2个和尚还是有2个盘子，命令：
① 第3个和尚你把第二柱子上的第1个盘子移动到第一柱子。
② 第2个和尚我把第2个盘子从第二柱子移动到第三柱子。
③ 第3个和尚你把第一柱子上的盘子移动到第三柱子。
分析组合起来就是：1→3 1→2 3→2 借助第三个柱子移动到第二个柱子 |1→3 自私人留给自己的活| 2→1 2→3 1→3借助第一个柱子移动到第三个柱子|共需要七步。
如果是4个盘子，则第一个和尚的命令中第1步和第3步各有3个盘子，所以各需要7步，共14步，再加上第1个和尚的1步，所以4个盘子总共需要移动7+1+7=15步，同样，5个盘子需要15+1+15=31步，6个盘子需要31+1+31=64步……由此可以知道，移动n个盘子需要（2的n次方）-1步。
从上面整体综合分析可知把n个盘子从1座（相当第一柱子）移到3座（相当第三柱子）：
（1）把1座上（n-1）个盘子借助3座移到2座。
（2）把1座上第n个盘子移动3座。
（3）把2座上（n-1）个盘子借助1座移动3座。
下面用hanoi（n,a,b,c）表示把1座n个盘子借助2座移动到3座。
很明显: (1)步上是 hanoi(n-1,1,3,2)
(3)步上是 hanoi(n-1,2,1,3)
用C语言表示出来，就是：
#include <stdio.h>
int method(int n,char a, char b)
{
printf("number..%d..form..%c..to..%c.."n",n,a,b);
return 0;
}
int hanoi(int n,char a,char b,char c)
{
if( n==1 ) move (1,a,c);
else
{
hanoi(n-1,a,c,b);
move(n,a,c);
hanoi(n-1,b,a,c);
};
return 0;
}
int main()
{
int num;
scanf("%d",&num);
hanoi(num,'A','B','C');
return 0;
}
原文：http://www.cnblogs.com/zhangqqqf/archive/2008/09/12/1289730.html
这个递归程序很简单，但是遇到复杂的递归算法可就不容易看懂了。以下这种方法能够帮助大家进行分析，但愿吧。
一．例子（用从C＋＋描述）：
行号 程序
0 p (int w)
1 {if（ w>o）
2 { cout<<w;
3 p(w-1);
4 p(w-1);
5 }
6 }
结束
执行语句 p(4) 后的打印结果：4 3 2 1 1 2 1 1 3 2 1 1 2 1 1
二．说明：
1．递归调用与普通的调用原理相同，只不过是每次调用的函数都是自己本身。
2．我们完全可以自己编程设置堆栈（用户堆栈），来实现与“递归调用”相同的功能。
3． 3.在“递归调用”时，系统会自动设置和管理堆栈（系统堆栈），而
无需我们的干预，但这同时增加了“递归调用”的神秘性。为了更好
地 地理解“递归调用”，现将系统堆栈以表格的方式表示出来。
4．对于“堆栈”格式的一些说明
堆栈的格式为：
|
方格a |
方格b |
方格c |
|
函数调用完返回的行号 |
调用的函数 |
W 的值 |
每调用一次函数就“入栈”一次；函数执行完了，就“出栈”一次
三．程序解释：
1．开始调用p(4)，此时执行的语句有：1、2、3
|
结束 |
P(4) |
4 |
执行p(4)的语句2：cout<<w; 打印4（这是第一个结果）
但是由于语句3，在执行过程中还要调用p(3)，只有p(3)执行完了，才能继续执行p(4)。
2．开始调用P(3)，此时执行的语句有：1、2、3
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
当p（3）执行完了，就会执行p(4)中的语句4（所以在方格a中，填“4”）。
执行p(3)的语句2：cout<<w; 打印3（这是第二个结果）
同上面的情况相同，当执行到语句3，还要调用p(2)，只有p(2)执行完了，才能继续执行p(3)。
3．开始调用P(2)，此时执行的语句有：1、2、3
|
4 |
P(2) |
2 |
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
执行p(2)的语句2：cout<<w; 打印2（这是第三个结果）
同上面的情况相同，当执行到语句3，还要调用p(1)，只有p(1)执行完了，才能继续执行p(2)。
4．开始调用P(1)，此时执行的语句有：1、2、3
|
4 |
P(1) |
1 |
|
4 |
P(2) |
2 |
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
执行p(2)的语句2：cout<<w; 打印1（这是第四个结果）
同上面的情况相同，当执行到语句3，还要调用p(0)，只有p(0)执行完了，才能继续执行p(1)。
5．开始调用P(0)，此时执行的语句有：1
|
4 |
P(0) |
0 |
|
4 |
P(1) |
1 |
|
4 |
P(2) |
2 |
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
因为w＝0不满足语句1，所以直接跳到语句5、6，从而p(0)执行完毕，p(0)要进行“出栈”操作。
6．此时执行的语句有：4
|
4 |
P(1) |
1 |
|
4 |
P(2) |
2 |
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
由于p(0)执行完成，且p(0)的方格a中为4，因此继续执行p(1)的语句4 ：p(w-1)； 又由于p(1)方格c中w值为1，所以调用p(0)。
7．开始调用p(0)
|
5 |
P(0) |
0 |
|
4 |
P(1) |
1 |
|
4 |
P(2) |
2 |
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
当p（0）执行完了，就会执行p(1)中的语句5（所以在方格a中，填“5”）。
因为w＝0不满足语句1，所以直接跳到语句5、6，从而p(0)执行完毕，p(0)要进行“出栈”操作。
8．此时执行的语句有：5
|
4 |
P(1) |
1 |
|
4 |
P(2) |
2 |
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
由于p(0)执行完成，且p(0)的方格a中为5，因此继续执行p(1)的语句5 （最后一句），所以p(1)执行完毕，p(1)要进行“出栈”操作。
9．
|
4 |
P(2) |
2 |
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
由于p(1)执行完成，且p(1)的方格a中为4，因此继续执行p(2)的语句4 ：p(w-1)； 又由于p(2)方格c中w值为2，所以调用p(1)。
10．开始调用P(1)，此时执行的语句有：1、2、3
|
5 |
P(1) |
1 |
|
4 |
P(2) |
2 |
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
当p（1）执行完了，就会执行p(2)中的语句5（所以在方格a中，填“5”）。
执行p(1)的语句2：cout<<w; 打印1（这是第五个结果）
当执行到语句3，还要调用p(0)，只有p(0)执行完了，才能继续执行p(1)。
11．始调用P(0)，此时执行的语句有：1
|
4 |
P(0) |
0 |
|
5 |
P(1) |
1 |
|
4 |
P(2) |
2 |
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
因为w＝0不满足语句1，所以直接跳到语句5、6，从而p(0)执行完毕，p(0)要进行“出栈”操作。
12．此时执行的语句有：4
|
5 |
P(1) |
1 |
|
4 |
P(2) |
2 |
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
由于p(0)执行完成，且p(0)的方格a中为4，因此继续执行p(1)的语句4 ：p(w-1)； 又由于p(1)方格c中w值为1，所以调用p(0)。
13．开始调用p(0)
|
5 |
P(0) |
0 |
|
5 |
P(1) |
1 |
|
4 |
P(2) |
2 |
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
当p（0）执行完了，就会执行p(1)中的语句5（所以在方格a中，填“5”）。
因为w＝0不满足语句1，所以直接跳到语句5、6，从而p(0)执行完毕，p(0)要进行“出栈”操作。
14．此时执行的语句有：5
|
5 |
P(1) |
1 |
|
4 |
P(2) |
2 |
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
由于p(0)执行完成，且p(0)的方格a中为5，因此继续执行p(1)的语句5 （最后一句），所以p(1)执行完毕，p(1)要进行“出栈”操作。
15．
|
4 |
P(2) |
2 |
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
由于p(1)执行完成，且p(1)的方格a中为5，因此继续执行p(2)的语句5 （最后一句），所以p(2)执行完毕，p(2)要进行“出栈”操作。
注意：其实步骤10～15重复了步骤4～9,因为它们都调用的P(1)
16．
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
由于p(2)执行完成，且p(2)的方格a中为4，因此继续执行p(3)的语句4 ：p(w-1)； 又由于p(3)方格c中w值为3，所以调用p(2)。
17．开始调用P(2)，此时执行的语句有：1、2、3
|
5 |
P(2) |
2 |
|
4 |
P(3) |
3 |
|
结束 |
P(4) |
4 |
当p（2）执行完了，就会执行p(3)中的语句5（所以在方格a中，填“5”）。
执行p(2)的语句2：cout<<w; 打印2（这是第六个结果）
同上面的情况相同，当执行到语句3，还要调用p(1)，只有p(1)执行完了，才能继续执行p(2)。
18．开始调用p(1)
省略……
注意：其实步骤17～29重复了3～15,因为它们都调用的P(2)
在这步骤中，又打印了2 1 1（见步骤3、4、10）
四．结论与分析：
|
步骤 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
|
结果 |
4 |
3 |
2 |
1 |
1 |
2 |
1 |
1 |
3 |
2 |
1 |
1 |
2 |
1 |
1 |
第5个结果重复第4个结果，这是因为他们都调用了p(1)
第6、7、8个结果重复第3、4、5个结果，这是因为他们都调用了p(2)
第9～15个结果重复第2～8个结果，这是因为他们都调用了p(3)
