数据结构与算法之递归算法

数据结构与算法之递归算法

递归概念

所谓递归，简单点来说，就是一个函数直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。
我们可以把” 递归 “比喻成 “查字典 “，当你查一个词，发现这个词的解释中某个词仍然不懂，于是你开始查这第二个词。可惜，第二个词里仍然有不懂的词，于是查第三个词，这样查下去，直到有一个词的解释是你完全能看懂的，那么递归走到了尽头，然后你开始后退，逐个明白之前查过的每一个词，最终，你明白了最开始那个词的意思。（摘自知乎的一个回答）
我们以阶乘作为：
int Factorial(int n){
if (n == 0) return 1;
return
n * Factorial(n - 1);
}

递归思想的内涵

更直接地说，递归的基本思想就是把规模大的问题转化为规模小的相似的子问题来解决。特别地，在函数实现时，因为解决大问题的方法和解决小问题的方法往往是同一个方法，所以就产生了函数调用它自身的情况，这也正是递归的定义所在。格外重要的是，这个解决问题的函数必须有明确的结束条件，否则就会导致无限递归的情况。
用归纳法来理解递归
数学归纳法适用于将解决的原问题转化为解决它的子问题，而它的子问题又变成子问题的子问题，而且我们发现这些问题其实都是一个模型，也就是说存在相同的逻辑归纳处理项。当然有一个是例外的，也就是归纳结束的那一个处理方法不适用于我们的归纳处理项，当然也不能适用，否则我们就无穷归纳了。总的来说，归纳法主要包含以下三个关键要素：
步进表达式：问题蜕变成子问题的表达式
结束条件：什么时候可以不再使用步进表达式
直接求解表达式：在结束条件下能够直接计算返回值的表达式
事实上，这也正是某些数学中的数列问题在利用编程的方式去解决时可以使用递归的原因，比如著名的斐波那契数列问题。

递归的三要素

1）、明确递归终止条件
我们知道，递归就是有去有回，既然这样，那么必然应该有一个明确的临界点，程序一旦到达了这个临界点，就不用继续往下递去而是开始实实在在的归来。换句话说，该临界点就是一种简单情境，可以防止无限递归。
2）、给出递归终止时的处理办法
我们刚刚说到，在递归的临界点存在一种简单情境，在这种简单情境下，我们应该直接给出问题的解决方案。一般地，在这种情境下，问题的解决方案是直观的、容易的。
3）、 提取重复的逻辑，缩小问题规模
我们在阐述递归思想内涵时谈到，递归问题必须可以分解为若干个规模较小、与原问题形式相同的子问题，这些子问题可以用相同的解题思路来解决。从程序实现的角度而言，我们需要抽象出一个干净利落的重复的逻辑，以便使用相同的方式解决子问题。

递归算法的编程模型

在我们明确递归算法设计三要素后，接下来就需要着手开始编写具体的算法了。在编写算法时，不失一般性，我们给出两种典型的递归算法设计模型，如下所示。
模型一： 在递去的过程中解决问题
function recursion(大规模){
if (end_condition){ // 明确的递归终止条件
end; // 简单情景
}else{ // 在将问题转换为子问题的每一步，解决该步中剩余部分的问题
solve; // 递去
recursion(小规模); // 递到最深处后，不断地归来
}
}
模型二： 在归来的过程中解决问题
function recursion(大规模){
if (end_condition){ // 明确的递归终止条件
end; // 简单情景
}else{ // 先将问题全部描述展开，再由尽头“返回”依次解决每步中剩余部分的问题
recursion(小规模); // 递去
solve; // 归来
}
}

递归问题实例

阶乘问题

问题：
用递归函数求x!

分析：
根据数学中的定义把求x! 定义为求x*(x-1)! ,其中求(x-1)! 仍采用求x! 的方法，需要定义一个求x！的函数，逐级调用此函数，即：
当x=0时，x!=1；当x>0时，x!=x*(x-1)！。
假设用函数Fac(x)表示x的阶乘，当x=3时，Fac(3)的求解方法可表示为：
Fac(3)=3fac(2)=32Fac(1)=321Fac(0)=3211=6
定义函数：int fac(int n)
如果n=0，则fac=1; 如果n>0，则继续调用函数fac=nfac(n-1);
返回主程序，打印fac(x)的结果。

#include<iostream>
　　using namespace std;
　　int fac(int );
　　int main()
　　{
　　int x;
　　cin>>x;
　　cout<<x<<"!="<<fac(x)<<endl;    //主程序调用fac(x) 求x !
　　return 0;
　　}
　int fac(int n)	                 //函数fac(n) 求n !
　　{
　　　return n==0 ? 1 : n*fac(n-1); //调用函数fac(n-1)递归求(n-1) !
　　}

问题：
用递归的方法求斐波那契数列中的第N个数

#include<iostream>
　　using namespace std;
　　int fib(int);
　　int main()
　　{
　　   int m;
          cin>>m;                              
　　   cout<<"fib("<<m<<")="<<fib(m);          
　　}
int fib(int n)
　　{
　　   if (n==0) return 0;                   //满足边界条件，递归返回
　　   if (n==1) return 1;                //满足边界条件，递归返回
　　   return (fib(n-1)+fib(n-2));             //递归公式，进一步递归
　　}

问题：
例如，下面给出了杨辉三角形的前4行：
1
1 1
1 2 1
1 3 3 1

int getValue(int x, int y) {
        if(y <= x && y >= 0){
            if(y == 0 || x == y){   // 递归终止条件
                return 1; 
            }else{  // 递归调用，缩小问题的规模
                return getValue(x-1, y-1) + getValue(x-1, y); 
            }
        }
        return -1;
    } 
}

问题：
古代有一个梵塔，塔内有三个座A、B、C，A座上有64个盘子，盘子大小不等，大的在下，小的在上。
有一个和尚想把这64个盘子从A座移到C座，但每次只能允许移动一个盘子，并且在移动过程中，3个座上的盘子始终保持大盘在下，
小盘在上。在移动过程中可以利用B座。要求输入层数，运算后输出每步是如何移动的。

void moveDish(int level, char from, char inter, char to) {
        if (level == 1) { // 递归终止条件
      cout<<("从" + from + " 移动盘子" + level + " 号到" + to)<<endl;
        } else {
      // 递归调用：将level-1个盘子从from移到inter(不是一次性移动，每次只能移动一个盘子,其中to用于周转)
          moveDish(level - 1, from, to, inter); // 递归调用，缩小问题的规模
          // 将第level个盘子从A座移到C座
          cout<<("从" + from + " 移动盘子" + level + " 号到" + to)<<endl; 
   // 递归调用：将level-1个盘子从inter移到to,from 用于周转
 moveDish(level - 1, inter, from, to); // 递归调用，缩小问题的规模
        }
    }
void main( ) {
        int nDisks = 30;
        moveDish(nDisks, 'A', 'B', 'C');
    }

问题：
从n个自然数（1，2，3，…，n）中取r个数的组合。例如当n=5，r=3时所有的组合如下：
5 4 3
5 4 2
5 4 1
5 3 2
5 3 1
5 2 1
4 3 2
4 3 1
4 2 1
3 2 1
Total=10{组合总数}
分析：
分析上面数据，组合数的规律如下：
（1）首先固定第一个数5，其后就是求解n=4，r=2的组合数，共6个组合。
（2）其次固定第一个数4，其后就是求解n=3，r=2的组合数，共3个组合。
（3）最后固定第一个数3，其后就是求解n=2，r=2的组合数，共1个组合。
这就找到了“5个数中3个数的组合” 与 “4个数中2个数的组合、3个数中2个数的组合、2个数中2个数的组合”的递归关系。
一般地，递归算法的两个步骤为：
（1） n个数中r个数的组合递推到“n-1个数中r-1个数的组合，n-2个数中r-1个数的组合，…，r-1个数中有r-1个数的组合”共有n-r+1次递归。
（2）递归的停止条件是r=1 。

int a[100];
void comb(int m,int k)
	{//求m个元素中取k个元素的组合
		int i,j;
		for(i=m;i>=k;i--)//从m到k进行循环
		{
			a[k]=i;
			if(k>1)
				comb(i-1,k-1,lb);//进行递归调用
			else
			{
				for(j=a[0];j>0;j--)  //显示对应的组合
				{
                  cout<<a[j]<< "   ";
				}
			}
		}
	}

问题：
一场球赛开始前，售票工作正在紧张进行中。每张球票为50元，现有30个人排队等待购票，其中20个人手持50元的钞票。另外10人手持100元的钞票，假设开始售票时售票处没有零钱，求出这30个人排队购票，使得售票处不至出现找不开钱的局面的不同排队种数（拿同样钞票的人兑换位置为同一种排队）
分析：
令f(m,n)表示有m个人手持50元，n个人手持100元排列的种数，则有：
n=0,全部都是50元的，排队种数为1种，及f(m,0)=1;
m<n,则有f(m,n)=0;
其它情况： f(m,n)=f(m,n-1)+f(m-1,n)。即是m个手持50元与n-1个手持100元的种数与m-1个手持50元与n个手持100元的种数的和。

#include <iostream>
using namespace std;
long long f(int j,int i)
{
	long long  y;
	if(i==0) y=1;
	else if(j<i) y=0;
	else y=f(j-1,i)+f(j,i-1);
	return y;
 } 
int main()
{
	int m,n;
	cin>>m>>n;
	cout<<f(m,n);
	return 0;
}

int main()
{
	int m,n,i,j;
	long long f[100][100]={0};
	cin>>m>>n;
	for(j=1;j<=m;j++)
		f[j][0]=1;
	for(j=0;j<=m;j++)
		for(i=j+1;i<=n;i++)
			f[j][i]=0;
	for(i=1;i<=n;i++)
		for(j=i;j<=m;j++)
			f[j][i]=f[j-1][i]+f[j][i-1];
	cout<<f[m][n];
	
}