递归~~~

一.定义

计算机科学中，递归是一种解决计算问题的方法，其中解决方案取决于同一类问题的更小子集。

比如单链表递归遍历的例子：

     void f(Node node){
         if (node == null){
             return;
         }
         f(node.next);
     }

说明：

1.自己调用自己，如果说每个函数对应着一种解决方案，自己调用自己意味着解决方案是一样的（有规律的）

2.每次调用，函数处理的数据会比较上次缩减（子集），而且最后会缩减至无需继续递归

3.内层函数调用（子集处理）完成，外层函数才能算调用完成

二：思路

1.确定能否使用递归求解

2.推导出递推关系，即父问题与子问题的关系，以及递归的结束条件

注：深入到最里层叫做递，从最里层出来叫做归，在递的过程中，外层函数内的局部变量（以及方法参数）并未消失，归的时候还可以用到。

三：例题

1.求阶乘

    private static int f(int n){
        if (n == 1){
            return 1;
        }
        return n*f(n-1);
    }

2.反向打印字符

    private static void f(int n,String str){
        if (n == str.length()){
            return;
        }
        f(n+1,str);
        System.out.println(str.charAt(n));
    }

3.二分查找

   public int f(int[]a,int target,int i,int j){
       if (i>j){
           return -1;
       }
       
       int m = (i+j)>>>1;
       if (target < a[m]){
           return f(a,target,i,m-1);
       } else if (a[m] < target) {
           return f(a,target,m+1,j);
       }else {
           return m;
       }
   }

4.冒泡排序

 //j代表未排序区域右边界
 private void bubble(int[] a,int j){
       if (j == 0){
           return;
       }
       for (int i = 0;i < j;i++){
           if (a[i] > a[i+1]){
               int t = a[i];
               a[i] = a[i+1];
               a[i+1] = t;
           }
       }
       bubble(a,j-1);
   }

优化版：当某一次递归后所有值已经有序，就不需要再进行接下来的代码了

 //j代表未排序区域右边界
 //x是i在交换前i对应的位置，若未发生交换，则x不变，则x右边值都是有序的
 private void bubble(int[] a,int j){
       if (j == 0){
           return;
       }
       int x = 0;
       for (int i = 0;i < j;i++){
           if (a[i] > a[i+1]){
               int t = a[i];
               a[i] = a[i+1];
               a[i+1] = t;
               x = i;
           }
       }
       bubble(a,x);
   }

5.插入排序

   //low为未排序区域的左边界
   private void insertion(int[] a,int low){
        if (low == a.length){
            return;
        }
       int t = a[low];//low位置的值
       int i = low-1; //已排序区域指针

       while(i >= 0 && a[i] > t){  //寻找小于t的第一个位置，没有找到插入位置
           a[i+1]=a[i];   //空出插入位置，即将a[i]值赋予low,直到找到插入位置
           i--;
       }
       //找到插入位置
       if (i+1 != low){   //例如2 3 4 要插入4时，已经是有序的，不需要再赋值了
           a[i+1]=t;
       }
       insertion(a,low+1);
   }

6.斐波那契数列

（1）代码实现

   public int f(int n){
       if (n == 0){
           return 0;
       }
       if (n == 1){
           return 1;
       }
       int x = f(n-1);
       int y = f(n-2);
       return x+y;
   }

（2）变体一：兔子问题

（3）变体二：青蛙爬楼梯

（4）优化版：记忆法

   public int fibonaci(int n){
      int[] cache = new int[n+1];//若n=5,则f(5)需存入cache[5]，从0开始需要6个长度
       Arrays.fill(cache,-1);//[-1,-1,-1,-1,-1,-1]
       cache[0] = 0;
       cache[1] = 1;//[0,1,-1,-1,-1,-1]
       return f(n,cache);
   }
    public int f(int n,int[] cache){
        if (cache[n] != -1){  //先在数组里找值
            return cache[n];  //找到直接返回
        }
        int x = f(n-1,cache);
        int y = f(n-2,cache);
        cache[n] = x + y;//[0,1,?,-1,-1,-1]存入数组
        return cache[n];
    }

7.杨辉三角

    //算出数字
    private static int element(int i,int j){
       if (j == 0 || i == j){
           return 1;
       }
       return element(i-1,j-1)+element(i-1,j);
    }
    //打印空格
    private static void printSpace(int n,int i){
       int num = (n-1-i)*2;
       for (int j=0;j<num;j++){
           System.out.print(" ");
       }
    }
    //打印数字
    public static void print(int n){
       for (int i=0;i<n;i++){
           printSpace(n,i);
           for (int j=0;j<=i;j++){
               System.out.printf("%4d",element(i,j));
           }
           System.out.println();
       }
    }

8.杨辉三角优化：记忆法

提前把值存入数组，就不需要重复计算

    //算出数字
    private static int element(int[][] triangle,int i,int j){
       if (triangle[i][j]>0){//先看数组里是否存在，开始时每个数都是0，若是有值则大于0
           return triangle[i][j];
       }
       if (j == 0 || i == j){
           triangle[i][j]=1;
           return 1;
       }
       triangle[i][j] = element(triangle,i-1,j-1)+element(triangle,i-1,j);
       return triangle[i][j];//将值存入数组
    }
    //打印空格
    private static void printSpace(int n,int i){
       int num = (n-1-i)*2;
       for (int j=0;j<num;j++){
           System.out.print(" ");
       }
    }
    //打印数字
    public static void print(int n){
       int[][] triangle = new int[n][];//每行有多少列不确定
       for (int i=0;i<n;i++){ //行
           triangle[i] = new int[i+1];//确定列，根据规律可得j=i+1，从第0行开始算
           printSpace(n,i);
           for (int j=0;j<=i;j++){
               System.out.printf("%4d",element(triangle,i,j));
           }
           System.out.println();
       }
    }

四：递归时间复杂度计算

1.公式法

2.展开求解