Java数据结构和算法（六）——递归
一、递归的定义
什么是递归：一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的为题来求解，递归策略只需少量的程序就可以描述出题解过程所需要的多次重复计算，大大的减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
也就是说，递归，就是在运行的过程中调用自己。
递归的三要素：
1、边界条件
2、递归前进段
3、递归返回段
当边界条件不满足时，递归前进；当边界条件满足时，递归返回。
二、求一个数的阶乘
规定：
①、0！=1
②、1！=1
③、负数没有阶乘
上面的表达式我们先用for循环改写：
//求n的阶乘，使用for循环
public static int getFactorialFor(int n){
int temp=1;
if(n>=0){
for (int i = 1; i < n; i++) {
temp=temp*i;
}
}else {
return -1;
}
return temp;
}
改用递归来写：
//求n的阶乘，递归写法
public static int getFactorialForOne(int n){
if(n>=0){
if(n==0){
System.out.println(n+"!=1");
return 0;
}else {
System.out.println(n);
int temp=n*getFactorialForOne(n-1);
System.out.println(n+"!="+temp);
return temp;
}
}
return -1;
}
三、递归的二分查找
注意：二分查找的数组一定是有序的！！！
在有序数组array[]中，不断将数组的中间值（mid）和被查找的值比较，如果被查找的值等于array[mid],就返回下标mid; 否则，就将查找范围缩小一半。如果被查找的值小于array[mid], 就继续在左半边查找;如果被查找的值大于array[mid], 就继续在右半边查找。 直到查找到该值或者查找范围为空时， 查找结束。
不用递归的二分查找：
//二分查找，一般方法
public static int findTwoPoint(int[] array,int key)
{
int start=0;
int last=array.length-1;
while (start<=last){
//防止直接相加造成int范围溢出
int mid=(last-start)/2+start;
//查找值等于当前值，返回数组下标
if(key==array[mid]){
return mid;
}
//查找值当前值大
if(key>array[mid]){
start=mid+1;
}
//查找值比当前值小
if(key<array[mid]){
last=mid-1;
}
}
return -1;
}
二分查找的递归写法：
//二分查找，递归方法
public static int search(int array[],int key,int low,int high){
int mid=(high-low)/2+low;
//查找值等于当前值，返回数组下标
if(key==array[mid]){
return mid;
}else if(low>high){
return -1;//查不到值返回-1
}else {
if(key<array[mid]){
return search(array,key,low,mid-1);//查找值比当前值小
}
if(key>array[mid]){
//查找值比当前值大
return search(array,key,low,high);
}
}
return -1;
}
递归的二分查找和非递归的二分查找效率都为O(logN)，递归的二分查找更加简洁，便于理解，但是速度会比非递归的慢。
四、分治算法
当我们求解某些问题时，由于这些问题要处理的数据相当多，或求解过程相当复杂，使得直接求解法在时间上相当长，或者根本无法直接求出。对于这类问题，我们往往先把它分解成几个子问题，找到求出这几个子问题的解法后，再找到合适的方法，把它们组合成求整个问题的解法。如果这些子问题还较大，难以解决，可以再把它们分成几个更小的子问题，以此类推，直至可以直接求出解为止。这就是分治策略的基本思想。
上面讲的递归的二分查找法就是一个分治算法的典型例子，分治算法常常是一个方法，在这个方法中含有两个对自身的递归调用，分别对应于问题的两个部分。
二分查找中，将查找范围分成比查找值大的一部分和比查找值小的一部分，每次递归调用只会有一个部分执行。
五、汉诺塔问题
汉诺塔问题是由很多放置在三个塔座上的盘子组成的一个古老的难题。如下图所示，所有盘子的直径是不同的，并且盘子中央都有一个洞使得它们刚好可以放在塔座上。所有的盘子刚开始都放置在A 塔座上。这个难题的目标是将所有的盘子都从塔座A移动到塔座C上，每次只可以移动一个盘子，并且任何一个盘子都不可以放置在比自己小的盘子之上。
试想一下，如果只有两个盘子，盘子从小到大我们以数字命名（也可以想象为直径），两个盘子上面就是盘子1，下面是盘子2，那么我们只需要将盘子1先移动到B塔座上，然后将盘子2移动到C塔座，最后将盘子1移动到C塔座上。即完成2个盘子从A到C的移动。
如果有三个盘子，那么我们将盘子1放到C塔座，盘子2放到B塔座，在将C塔座的盘子1放到B塔座上，然后将A塔座的盘子3放到C塔座上，然后将B塔座的盘子1放到A塔座，将B塔座的盘子2放到C塔座，最后将A塔座的盘子1放到C塔座上。
如果有四个，五个，N个盘子，那么我们应该怎么去做？这时候递归的思想就很好解决这样的问题了，当只有两个盘子的时候，我们只需要将B塔座作为中介，将盘子1先放到中介塔座B上，然后将盘子2放到目标塔座C上，最后将中介塔座B上的盘子放到目标塔座C上即可。
所以无论有多少个盘子，我们都将其看做只有两个盘子。假设有 N 个盘子在塔座A上，我们将其看为两个盘子，其中(N-1)~1个盘子看成是一个盘子，最下面第N个盘子看成是一个盘子，那么解决办法为：
①、先将A塔座的第(N-1)~1个盘子看成是一个盘子，放到中介塔座B上，然后将第N个盘子放到目标塔座C上。
②、然后A塔座为空，看成是中介塔座，B塔座这时候有N-1个盘子，将第(N-2)~1个盘子看成是一个盘子，放到中介塔座A上，然后将B塔座的第(N-1)号盘子放到目标塔座C上。
③、这时候A塔座上有(N-2)个盘子，B塔座为空，又将B塔座视为中介塔座，重复①，②步骤，直到所有盘子都放到目标塔座C上结束。
简单来说，跟把大象放进冰箱的步骤一样，递归算法为：
①、从初始塔座A上移动包含n-1个盘子到中介塔座B上。
②、将初始塔座A上剩余的一个盘子（最大的一个盘子）放到目标塔座C上。
③、将中介塔座B上n-1个盘子移动到目标塔座C上。
/**
* 汉诺塔问题
* @param dish 盘子个数
* @param from 初始塔座
* @param temp 中介塔座
* @param to 目标塔座
*/
public static void move(int dish,String from,String temp,String to){
if(dish==1){
System.out.println("将盘子"+dish+"从塔座"+from+"移动到"+to);
}else {
move(dish-1,from,to,temp);//A为初始塔座，B为目标塔座，C为中介塔座
System.out.println("将盘子"+dish+"从塔座"+from+"移动到"+to);
move(dish-1,temp,from,to);//为初始塔座，B为目标塔座，A为中介塔座
}
}
六、归并排序
归并算法的中心是归并两个已经有序的数组。归并两个有序数组A和B，就生成了第三个有序数组C。数组C包含数组A和B的所有数据项。
非递归算法：
/**
* 归并排序，(非递归)传入两个有序数组a和b，返回一个排好序的合并数组
* @param a
* @param b
* @return
*/
public static int[] sort(int[] a,int[] b){
int[] c=new int[a.length+b.length];
int aNum=0,bNum=0,cNum=0;
while (aNum<a.length&&bNum<b.length){
//比较a数组和b数组的元素，将小的值赋值给c数组
if(a[aNum]>=b[bNum]){
c[cNum++]=b[bNum++];
}else {
c[cNum++]=a[aNum];
}
}
//如果a数组全部赋值到了c数组，但是b数组还有元素，
// 则将b数组剩余的元素按顺序全部赋值到c数组
while (aNum==a.length&&bNum<b.length){
c[cNum++]=b[bNum++];
}
//同样如果b数组赋值完，a数组有剩余
while (bNum==b.length&&aNum<a.length){
c[cNum++]=a[aNum++];
}
return c;
}
该方法有三个while循环，第一个while比较数组a和数组b的元素，并将较小的赋值到数组c；第二个while循环当a数组所有元素都已经赋值到c数组之后，而b数组还有元素，那么直接把b数组剩余的元素赋值到c数组；第三个while循环则是b数组所有元素都已经赋值到c数组了，而a数组还有剩余元素，那么直接把a数组剩余的元素全部赋值到c数组。
归并排序的思想是把一个数组分成两半，排序每一半，然后用上面的sort()方法将数组的两半归并成为一个有序的数组。如何来为每一部分排序呢？这里我们利用递归的思想：
把每一半都分为四分之一，对每个四分之一进行排序，然后把它们归并成一个有序的一半。类似的，如何给每个四分之一数组排序呢？把每个四分之一分成八分之一，对每个八分之一进行排序，以此类推，反复的分割数组，直到得到的子数组是一个数据项，那这就是这个递归算法的边界值，也就是假定一个数据项的元素是有序的。
/**
* 递归写法
* @param c
* @param start
* @param last
* @return
*/
public static int[] mergeSort(int[] c,int start,int last){
if(last>start){
//也可以写成（start+last）/2，这种写法为了防止数组长度很大造成两者相加超出int的范围
int mid=start+(last-start)/2;
mergeSort(c,start,mid);//左边数组排序
mergeSort(c,mid+1,last);//右边数组排序
merge(c,start,mid,last);//合并左右数组
}
return c;
}
public static void merge(int[] c,int start,int mid,int last){
int[] temp=new int[last-start+1];//定义临时数组
int i=start;//定义左边数组的下标
int j=mid+1;//定义右边数组的下标
int k=0;
while (i<=mid&&j<=last){
if(c[i]<c[j]){
temp[k++]=c[i++];
}else {
temp[k++]=c[j++];
}
}
//把左边剩余数组元素移入新数组
while (i<=mid){
temp[k++]=c[i++];
}
//把右边剩余数组元素移入新数组
while (j<=last){
temp[k++]=c[j++];
}
//把新数组中的数覆盖到c数组中
for (int k2=0;k2<temp.length;k2++){
c[k2+start]=temp[k2];
}
}
七、消除递归
一个算法作为一个递归的方法通常通概念上很容易理解，但是递归的使用在方法的调用和返回都会有额外的开销，通常情况下，用递归能实现的，用循环都可以实现，而且循环的效率会更高，所以在实际应用中，把递归的算法转换为非递归的算法是非常有用的。这种转换通常会使用到栈。
递归和栈
递归和栈有这紧密的联系，而且大多数编译器都是用栈来实现递归的，当调用一个方法时，编译器会把这个方法的所有参数和返回地址都压入栈中，然后把控制转移给这个方法。当这个方法返回时，这些值退栈。参数消失了，并且控制权重新回到返回地址处。
调用一个方法时所发生的事：
一、当一个方法被调用时，它的参数和返回地址被压入一个栈中；
二、这个方法可以通过获取栈顶元素的值来访问它的参数；
三、当这个方法要返回时，它查看栈以获得返回地址，然后这个地址以及方法的所有参数退栈，并且销毁。
八、递归应用
乘方的计算：
如果如果求28次方，我们可以先假定22=a,于是28 = （22）4 ，那么就是a4 ；假定 a2 = b，那么 a4 = b2，而b2可以写成(b2)1。于是现在28就转换成：b*b
//乘方的运算可以转换为乘法的运算
public static int pow(int x,int y){
if(x==0||x==1){
return x;
}
if(y>1){
int b=y/2;
int a=x*x;
if(y%2==1){
return pow(a,b)*x;
}else {
return pow(a,b);
}
}else if(y==0){
return 1;
}else {
//y=1
return x;
}
}
九、总结
一个递归方法每次都是用不同的参数值反复调用自己，当某种参数值使得递归的方法返回，而不再调用自身，这种情况称为边界值，也叫基值。当递归方法返回时，递归过程通过逐渐完成各层方法实例的未执行部分，而从最内层返回到最外层的原始调用处。
阶乘、汉诺塔、归并排序等都可以用递归来实现，但是要注意任何可以用递归完成的算法用栈都能实现。当我们发现递归的方法效率比较低时，可以考虑用循环或者栈来代替它。
2201
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
