转自：C++ 递归算法

递归算法，总结起来具有以下几个特点：

    
特点1  它有一个
基本部分，即直接满足条件，输出    
 特点2  它有一个
递归部分，即 通过改变基数（即n），来逐步使得n满足基本部分的条件，从而输出

    
特点3  在实现的过程中，它采用了分治法的思想：        即将
整体分割成部分，
并总是从最小的部分（基本部分）开始入手（输出），其背后的原理在于 当整体递归到部分时，会保留整体的信息，部分满足条件输出的结果会被回溯给整体使用，从而使得整体输出结果。

   
 特点4  每一步操作，整体都会将部分当作其必要的一个步骤，从而实现整体步骤的完成

下面以几个例子验证以上4点：  
 
  例子1： 全排列        描述： 有n个数时， 输出n个数的所有排列组合        分析：             
假设有 abc三个数，           特点3： 整体分割为局部，从基本部分开始输出              那么其输出为 abc, acb,      bac, bca,     cba, cab。               abc, bac, cba 三种情况下，都会从整体过度到 部分， 即 abc->bc,   bac->ac, cba->ba, 而相应的 bc, ac, ba,  又会有               
cb, ca, ab的情况．即　perm(abc)->  a*perm(bc)+b*perm(ac)+c*perm(ba)　　（perm为排列的意思）          特点1：             当perm(bc)->b*perm(c)时，即perm的数目只有一个时，即为输出          特点2：             perm(abc)->perm(bc)->perm(c)即 perm的数目递减的过程，为递归部分          特点4： 将递归的操作作为自操作，完成当前整体的操作           一次，在一次整体的操作中，　需要abc,  bac, cba三个，进行整体到部分的操作（即递归操作）。              而abc, bac, cba 是a 与 b, 与c交换的结果，因此，答案就出来了：

[cpp] 
view plain
 copy

1. //Implementation Permutation n numbers  
2. //交换位置  
3. template<class T>  
4. void swap(T &a, T &b)  
5. {  
6.     T temp = a;  
7.     a = b;  
8.     b = temp;  
9. }  
10.   
11.   
12. //全排列,  
13. //list为排列的数的数组，如{1, 2, 3}   
14. //int k 为排列数组的起始点，int m 为排列数组的终点  
15. //如k=0,m=2  将1,2,3进行全排列，当 k=1,  m=2,将2,3全排列  
16.   
17. template<class T>  
18. void permulateNumber(T list[], int k, int m)  
19. {  
20.     if (k == m) //输出条件，整体变部分，k 逐渐逼近 m直到=m  
21.     {  
22.         //特点1 基本部分, 完成数组从第一个到最后一个数的输出  
23.         for (int i = 0; i <= m; ++i)  
24.         {  
25.             std::cout << list[i];  
26.         }  
27.         std::cout << std::endl;  
28.     }  
29.     else{//特点2 递归部分  
30.           
31.         //以下为特点4  
32.         for (int i = k; i <= m; ++i)  
33.         {  
34.               
35.             swap(list[k], list[i]);  // 完成当前排列部分中，第一个数，与后面数的交换  
36.             permulateNumber(list, k + 1, m); //特点3 整体到部分  
37.             swap(list[i], list[k]);   
38.         }  
39.     }  
40. }  

例子2： 阶乘 n!   n!=n*(n-1)!=n*n-1*(n-2)!=…..

  分析的过程如 例子1：   直接上代码：   
[cpp] 
view plain
 copy

1. int factorial(int n)  
2. {  
3.       
4.     if (n == 0 || n == 1)  // 输出条件  
5.     {  
6.         return 1;  //特点1 基本部分  
7.     }  
8.     else{//特点2  
9.         // 特点4   整体利用部分结果  
10.         return n*factorial(n – 1); // 特点3 递归部分，   
11.     }  
12. }  

例子3：汉诺塔问题：   问题描述：    有n个盘子， 从小到大 依此从上往下叠放，在1号位。  1号位，2号位，3号位从左到右相邻。    现需要将n个盘子，从1号位通过2号位移到3号位，或者从3号位置通过2号移到1号。  移动的过程中，不允许，大盘叠在小盘上。

  问题分析：自行分析

  上代码：    
[cpp] 
view plain
 copy

1. //n 为 盘子的数目  
2. //a 为1号位， b 为2号位， c为3号位  
3. void  hanoi(int n, char a, char b, char c)  
4. {  
5.     if (n == 1) // 输出条件  
6.     {  
7.         std::cout << a << b << c << std::endl; //特点1，基本部分  
8.     }  
9.     else{ // 特点2 递归部分  
10.         //特点4： 以下为  整体利用部分为其一步，完成当前整体整个步骤   
11.         hanoi(n – 1, a, b, c);  //特点3  整体化为部分，部分视为1步，即将n-1个盘子 从a 移到c   
12.         std::cout << a << b << std::endl; // 第n个盘子从 a 到 b  
13.         hanoi(n – 1, c, b, a); // 特点3  
14.         std::cout << b << c << std::endl;  
15.         hanoi(n – 1, a, b, c); //特点3  
16.     }  
17. }  

至此，递归算法的特点和大体实现过程分析完毕。