【JAVA】递归

递归的思想
递归：你打开面前这扇门，看到屋里面还有一扇门。你走过去，发现手中的钥匙还可以打开它，你推开门，发现里面还有一扇门，你继续打开它。若干次之后，你打开面前的门后，发现只有一间屋子，没有门了。然后，你开始原路返回，每走回一间屋子，你数一次，走到入口的时候，你可以回答出你到底用这你把钥匙打开了几扇门。
　　 循环：你打开面前这扇门，看到屋里面还有一扇门。你走过去，发现手中的钥匙还可以打开它，你推开门，发现里面还有一扇门（若前面两扇门都一样，那么这扇门和前两扇门也一样；如果第二扇门比第一扇门小，那么这扇门也比第二扇门小，你继续打开这扇门，一直这样继续下去直到打开所有的门）。但是，入口处的人始终等不到你回去告诉他答案。

1. 什么是递归？

递归是在函数的定义中使用函数自身的方法
2.递归内涵？
递归就是有递去还有归来
去：递归是指递归问题可以分解为若干个规模较小，与原问题形式相同的问题，这些子问题可以用相同的解题思路来解决，就像上面的例子中的钥匙可以打开后面所有门上的锁一样；归：就是说这些问题的演化过程是一个由大到小的过程，并且会有一个明确的终点，一旦达到这个临界点，就不用往更小、更远的地方走下去。最后，从这个临界点开始，原路返回到原点，原问题就得到了解决。

更直接地说，递归的基本思想就是把规模大的问题转化为规模小的子问题去解决。特别，在函数实现时，因为解决大的问题和解决小的问题往往是同一个方法，所以就产生了调用它自身的情况，这就是递归的定义所在。重要的是，解决问题的函数必须有明确的结束条件，否则就会导致无限递归的情况。
3.递归三要素
1）明确递归终止条件
2）给出递归终止时的解决办法
3）提取重复的逻辑，缩小问题的规模

例题：
1.递归实现二分查找

//递归实现二分查找
    public static int binarySearch(int[] list, int key){
        if(list == null || list.length == 0){
            return -1;
        }

        return binaySearchBrRecur(list, key, 0, list.length-1);
    }

    public static int binaySearchBrRecur(int[] list, int key, int low, int high){
        if(low <= high){//提取重复逻辑，缩小问题规模
            int mid = (low+high) >> 1;
            if(list[mid] == key){
                return mid;//明确递归终止条件并给出终止条件的解决办法
            }else if(list[mid] > key){
                return binaySearchBrRecur(list, key, low, mid-1);
            }else{
                return binaySearchBrRecur(list, key, mid+1, high);
            }
        }
        return -1;
    }

2.递归实现阶乘

public static long factorialByRecur(int n){
        if(n == 1){
            return 1;//递归终止条件+处理办法
        }
        //提取相同重复逻辑，来解决小规模问题
        return n * factorialByRecur(n-1);
    }

3.递归实现斐波那契数列

//递归实现斐波那契数列
    public static long fibonacciByRecur(int n){
//        if(n == 0) return 0;
//        if(n == 1) return 1;
        if(n == 1 || n == 2)  return 1; //递归终止条件+处理办法

        //提取相同重复逻辑，来解决小规模问题
        return fibonacciByRecur(n-1)+fibonacciByRecur(n-2);
    }

4.递归去实现回文字符串判断

 //递归去实现回文字符串判断
    public static boolean isPlalindromeString(String s, int start, int end){
//        int start = 0;
//        int end = s.length()-1;
        if(s == null || s.length() == 0 || start > end) return false;

        if(start < end){
            if(s.charAt(start) != s.charAt(end)){
                return false;//递归的终止条件+解决办法
            }else {
                //缩小问题规模，提取重复逻辑
                return isPlalindromeString(s, start+1, end-1);
            }
        }
        return true;
    }

5.递归实现杨辉三角

//递归实现杨辉三角
public long PascalTriangle(int m,int n){
        if(n>m)
            return 0;
        else if(n==0 || n==m)
            return 1;
        else return PascalTriangle(m-1,n)+PascalTriangle(m-1,n-1);
    }

6.递归实现汉诺塔

public class Hanoi{
    private static int count=0;
    public static void move(char A,int n,char B ){
        System.out.println("Move "+ n +" from " + A +" to " + B);
    }
    public static void Hanoi(int n,char A,char B,char C){
        count++;
        if(n==1){
            move(A,n,C);
        }else{
            Hanoi(n-1,A,C,B);
            move(A,n,C);
            Hanoi(n-1,B,A,C);
        }
    }
    public static void main(String[] arges){
        Hanoi(5,'A','B','C');
        System.out.println("总共移动了"+ count + "次");
    }
}