递归

递归的优点：

简洁，代码量小，比循环简单

缺点：不易理解，如果递归太深有可能出现溢出栈。

递归的思想：就是将大规模的问题转化为相识的规模小，具有原来问题相同解法的问题，要存在一个临界值使得循环可以停止。

例子：

1.求阶乘

public static int fac1(int n){//递归：保护现场
     int tmp = 1;
     if(n == 1){
          return tmp;
     }else{
          tmp = n * fac1(n-1);
     }
     return tmp;
}
public static void main(String[] args) {
     System.out.println(fac1(5));
     }
     }

2.汉诺塔

  public static void move(char pos1,char pos2){

          System.out.println(pos1 + "==>"+pos2+"");
     }
public static void hannio(char pos1,char pos2,char pos3,int n){
          if (n==1){
               move(pos1,pos3);
          }else{
               hannio(pos1,pos3,pos2,n-1);
               move(pos1,pos3);
               hannio(pos2,pos1,pos3,n-1);
          }
}
public static void main(String[] args) {
hannio('A','B','c',9);
}
}

3.二分查找

public static int binarySearch(int left, int right, int key, int[] array) {

    if (left <= right) {
        int mid = (left + right) >>> 1;
        if (key == array[mid]) {
            return mid;
        } else if (key > array[mid]) {
            return binarySearch(mid + 1, right, key, array);
        } else {
            return binarySearch(left, mid - 1, key, array);
        }
    }
        return -1;
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5,6,7};
System.out.println(binarySearch(0,array.length-1,5,array));
}
}

4.斐波那契求和及单个：

  public static int faibonci(int n) {
        if (n <= 0) {
            return -1;
        }
        int tmp = 1;
        if (n == 1) {
            return tmp;
        } else {
            if (n == 2) {
                return ++tmp;
            } else {
                tmp = tmp + faibonci(n - 1) + faibonci(n - 2);
            }
            return tmp;
        }
    }

    //求单个的：
/*    int tmp = 1;
    if（n ==1||n ==2）{
        return tmp;
    }else{
        tmp = faibonci(n - 1) + faibonci(n - 2);
    }
    return tmp;
}*/
public static void main(String[] args) {
    System.out.println(faibonci(5));
    }
  }