递归的几个例子

p.s.写在前面
递归就是分清楚一和整体（规律） ，要找到递归式（就是把一和整体联系在一起的公式），然后一定要有递归边界，否则将无边界的递归下去。
解释下
一：就是分离出来的一项
整体：就是剩下的需要解决的项，将它们看作一个整体
然后只需要将一与整体联系起来就可以完成特定的功能。
·强烈建议写递归之前一定要把递归的式子和递归边界找到再写，不然很可能会把自己弄晕。
·循环一定可以写成递归，递归不一定可以写成循环。循环可以用开辟栈空间来重复处理问题来实现，但是递归中的

1.实现1到100求和

#include<iostcream>
using namespace std;
int add1(int n)
{
	if(n==1) return 1;
	else return n+add1(n-1);
}
int add2(int n)
{
	if(n==100) return 100;
	else return n+add2(n+1);
}
int add3(int n)
{
	int f;
	if(n==1) f=1;
	else f=n+add3(n-1);
	return f;
}
int add4(int n)
{
	int f;
	if(n==100) f=100;
	else f=n+add4(n+1);
	return f;
}
int main()
{
	cout<<add1(100)<<endl;
	cout<<add2(1)<<endl;
	cout << add3(100) << endl;
	cout << add4(1) << endl;
	return 0;
}

p.s.
用到的两个递归如下
1.递归式子：n+sum(n-1)，递归边界：n=1，返回值1。
2.递归式子：n+sum(n+1)，递归边界：n=100，返回值100。
我用了正序和逆序，并且每种用了两个写法。前两种的写法比较简洁，后两种写法比较容易理解。

2.实现查找最大值

#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<iomanip>
using namespace std;
int a[100];
void set()
{
	for(int i=0;i<=99;++i)
		a[i]=rand();
}
void out()
{
	for(int i=0;i<=99;++i)
	{
		cout<<setw(8)<<a[i];
		if((i+1)%5==0) cout<<endl;
	}
}
int m1(int n)
{
	if(n==0) return a[0];
	else return max(a[n],m1(n-1));
}	
int m2(int n)
{
	if(n==99) return a[n];
	else return max(a[n],m2(n+1));
}
int m3(int n)
{
	int f;
	if(n==0) f=a[0];
	else f=max(a[n],m3(n-1));
	return f;
}
int m4(int n)
{
	int f;
	if(n==99) f=a[n];
	else f=max(a[n],m4(n+1));
	return f;
}
int main()
{
	set();
	cout<<m1(99)<<endl;
	cout<<m2(0)<<endl;
	cout<<m3(99)<<endl;
	cout<<m4(0)<<endl;
	out();
	return 0;
}

p.s.
用到的递归如下 （我们用一维数组来存储数据）
1.递归式子：max(n,max(n-1,head))，递归边界：n-1=head，返回head处的值。
2.递归式子：max(n,max(n+1,tail))，递归边界：n+1=tail，返回tail处的值。
set函数用来设置数组的初始值，
out函数用来输出数组用来检查。

3.实现冒泡排序

#include<iostream>
#include<iomanip>
using namespace std;
int a[100],b[100];
void set()
{
	for(int i=0;i<=99;++i)
	{
		a[i]=rand();
		b[i]=a[i];
	}
}
void out(int a[])
{
	for(int i=0;i<=99;++i)
	{
		cout<<setw(8)<<a[i];
		if((i+1)%5==0) cout<<endl;
	}
}
void sort1(int n)
{
	if(n==0) return ;
	else
	{
		for(int i=0;i<n;++i)
		{
			int temp;
			if(a[i]<a[i+1])
			{
				temp=a[i];
				a[i]=a[i+1];
				a[i+1]=temp;
			}
		}
		sort1(n-1);
	}
}
void sort2(int n)
{
	if(n==99) return ;
	else
	{
		for(int i=99;i>n;--i)
		{
			int temp;
			if(b[i]>b[i-1])
			{
				temp=b[i];
				b[i]=b[i-1];
				b[i-1]=temp;
			}
		}
		sort2(n+1);
	}
}
int main()
{
	set();
	sort1(99);
	out(a);
	sort2(0);
	out(b);
	return 0;
}

p.s.
用到的递归如下（同样使用一维数组来存储数据）
1.递归式子：冒一次泡然后sort(n-1)，递归边界：n=head,返回值空。从前往后冒泡
2.递归式子：冒一次泡然后sort(n+1)，递归边界：n=tail，返回值空。从后往后冒泡

4.汉诺塔

#include<iostream>
using namespace std;
void move(int n,char start,char temp,char target)
{
	if(n<=0)
	{
		cout<<"Input error!";
		return ;
	}
	if(n==1||n==2)
	{
		if(n==1)
		{
			cout<<start<<"-->"<<target<<endl;
			return ;
		}
		else
		{
			cout<<start<<"-->"<<temp<<endl;
			move(n-1,start,temp,target);
			cout<<temp<<"-->"<<target<<endl;
			return ;
		}
	}
	else
	{
		move(n-1,start,target,temp);
		move(1,start,temp,target);
		move(n-1,temp,start,target);
	}
}
int main()
{
	int n;
	cin>>n;
	move(n,'A','B','C');
	return 0;
}

p.s.
递归式子:
move(n-1,start,temp,target);
move(1,start,temp,target);
move(n-1,temp,start,target);
递归边界：
n=1 start–>target;
n=2 start–>temp;start–>target;temp–>target;

总结：递归是一种比较清楚表达出思想的算法，是用空间换时间的算法，是能够代替循环的算法，但是循环不能代替递归。