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交换的结果，因此，答案就出来了：

//Implementation Permutation n numbers
//交换位置
template<class T>
void swap(T &a, T &b)
{
	T temp = a;
	a = b;
	b = temp;
}


//全排列,
//list为排列的数的数组，如{1, 2, 3} 
//int k 为排列数组的起始点，int m 为排列数组的终点
//如k=0,m=2  将1,2,3进行全排列，当 k=1,  m=2,将2,3全排列

template<class T>
void permulateNumber(T list[], int k, int m)
{
	if (k == m) //输出条件，整体变部分，k 逐渐逼近 m直到=m
	{
		//特点1 基本部分, 完成数组从第一个到最后一个数的输出
		for (int i = 0; i <= m; ++i)
		{
			std::cout << list[i];
		}
		std::cout << std::endl;
	}
	else{//特点2 递归部分
		
		//以下为特点4
		for (int i = k; i <= m; ++i)
		{
			
			swap(list[k], list[i]);  // 完成当前排列部分中，第一个数，与后面数的交换
			permulateNumber(list, k + 1, m); //特点3 整体到部分
			swap(list[i], list[k]); 
		}
	}
}

例子2： 阶乘 n!

  n!=n*(n-1)!=n*n-1*(n-2)!=.....

  分析的过程如 例子1：

  直接上代码：

  

int factorial(int n)
{
	
	if (n == 0 || n == 1)  // 输出条件
	{
		return 1;  //特点1 基本部分
	}
	else{//特点2
		// 特点4   整体利用部分结果
		return n*factorial(n - 1); // 特点3 递归部分， 
	}
}

例子3：汉诺塔问题：

  问题描述：

   有n个盘子， 从小到大 依此从上往下叠放，在1号位。  1号位，2号位，3号位从左到右相邻。

   现需要将n个盘子，从1号位通过2号位移到3号位，或者从3号位置通过2号移到1号。  移动的过程中，不允许，大盘叠在小盘上。

  问题分析：自行分析

  上代码：

   

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

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