数据结构4——递归算法

递归算法：开始不断的调用自己，直到到达递归的出口，当到达递归的出口之后，最后调用的最先返回。做递归算法最重要的是找到出口。

就好比栈 ，开始一直往栈里面装入东西，直到抵达出口的时候才开始往外面拿东西。

图示左边先不断的调用，右边是从栈顶开始不断的返回。

实例1：求阶乘

package com.hone.recursion;

public class fact {
    public static long fact(int n){
        int x;
        long y;
        
        if (n<0) {
            System.out.println("请输入正确的参数");
        }
        if (n==0) return 1;
        else{
            x=n-1;
            y=fact(x);
            return n*y;
        }
    }
    
    public static void main(String[]  args){
        long fn;
        fn=fact(3);
        System.out.println("fn= "+fn);
        
    }
}

过程图

实例2：用对半法来查找

package com.hone.recursion;

public class BinSearch {
    public static int bSearch(int[] a, int x, int low,int high){
        int mid;
        if (low>high) return -1;
        
        mid=(low+high)/2;
        if (a[mid]>x) {
            return bSearch(a, x, low, mid-1);
        }
        else if (a[mid]<x) {
            return bSearch(a, x, mid+1, high);
        }
        else 
            return mid;
    }
    
    public static void main(String[] args) {
        int[] a={1,4,6,9,11,14,17,23,33,36,79,119,345,678,890};
        int x=33;
        int low=0;
        int high=a.length-1;
        System.out.println(high);
        int re=bSearch(a, x, low, high);
        if(re==-1){
            System.out.println("x不在数组中....");
        }
        else{
            System.out.println("x在数组中的下标值为："+re);
        }
    }
}    

实例3：汉诺塔游戏

package com.hone.recursion;

public class HanNoiTower {
    
    public static void towers(int n ,char from ,char To, char aux){
        
        if (n==1) {
            System.out.println("Move disk 1 from "+from +" To "+To);
            return ;
        }
        
        //思路，首先应该将n-1个盘子在C的帮助下从A移到B
        towers(n-1, from, aux, To);
        
        //在将盘子n从A直接移动c中 
        System.out.println("move disk "+n +" from " +from+" To "+ To);
        
        //再将剩余的n-1个盘子在A的帮助下从B移动到C中
        towers(n-1, aux, To, from);
    }
    public static void main(String[] args) {
        towers(4, 'A', 'B', 'C');
    }

}

汉诺塔用递归调用是最好的实例，你只需要有大致的思路，其他的都可以交给算法来处理。

了解递归的运行过程，最好的办法就是用debug模式来分析程序运行的过程。

在很多情况下，递归能实现的事情，通常循环也可以实现。而且循环所需要的时间复杂度远远的低于递归的时间复杂度。