递归

递归的概念：

递归，就是在运行的过程中调用自己，每次调用时传入不同的变量。使用递归可以我们解决复杂的问题，同时也使得我们的代码更加简洁。

递归的调用规则：

1.当程序执行一个方法时，就会开辟一个独立的空间（栈）
2.每个空间的数据是（局部变量）独立的，不会相互影响。
3.如果方法中使用的是引用类型的变量（比如 数组），就会共享该引用类型的数据。
4.递归必须向退出递归的条件逼近，否则就是无限递归，会出现栈溢出异常。
5.当一个方法执行完毕，或者遇到return，就会返回，遵循谁调用，就把结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

递归能解决什么问题：
1.各种数学问题:八皇后问题，汉诺塔，阶乘问题，迷宫问题。。。
2.各种算法中也会有递归实现：快排，归并排序，二分查找，分治算法。。。
3.利用栈解决的问题->递归更加简洁。

递归的使用举例：

斐波那契数列：
斐波那契数列，又称黄金分割数列、因数学家列昂纳多·斐波那契以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……这个数列从第3项开始，每一项都等于前两项之和。
一般而言，兔子在出生两个月后，就有繁殖能力，一对兔子每个月能生出一对小兔子来。如果所有兔子都不死，那么一年以后可以繁殖多少对兔子？
我们不妨拿新出生的一对小兔子分析一下：
第一个月小兔子没有繁殖能力，所以还是一对
两个月后，生下一对小兔对数共有两对
三个月以后，老兔子又生下一对，因为小兔子还没有繁殖能力，所以一共是三对。
。。。
依次类推可以列出下表：

幼仔对数=前月成兔对数
成兔对数=前月成兔对数+前月幼仔对数
总体对数=本月成兔对数+本月幼仔对数
可以看出幼仔对数、成兔对数、总体对数都构成了一个数列。这个数列有关十分明显的特点，那是：前面相邻两项之和，构成了后一项。

代码实现：

public static long isRecursion(int n){
    if (n == 0)
        return 0;
    if (n == 1)
        return 1;
    if (n > 1)
        return isRecursion(n-1) + isRecursion(n-2);
    else
        return -1;
}

结果图如下：

八皇后问题：

问题说明：
八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法？

思路分析：
1.第一个皇后先放第一行第一列
2.第二个皇后放在第二行第一列，然后判断是否不能相互攻击，如果可以相互攻击，继续放在第二列，第三列，第四列。。。依次把所有的列放完，找到一个合适的
3.继续放第三个皇后，还是第一列，第二列。。直到第八个皇后也能放在一个不冲突的位置，算是找到一个正确解
4.在得到正确解时，在栈回退到上一个栈时，就会开始回溯，将第一个皇后放在第一列的所有正确解，全部得到
5.将第一个皇后放在第二列，循环执行上述步骤

代码实现：

public class Queue8 {
    //表示有多少个皇后
     int max = 8;
     static int count=0;  //统计多少种解法
     static int counts=0;   //判断多少次
     //保存皇后放置位置的结果 如0 4 7 5 2 6 1 3  表示第一行第一列（0），第二行第五列（4）..
     //即对应下标表示第几行，arr[i]=val ,val表示第i+1个皇后，放在第i+1行的第val+1列
     int[] arr = new int[max];
     public static void main(String[] args) {
     Queue8 queue = new Queue8();
     queue.check(0);
     System.out.printf("一共有%d种解法",count);
     System.out.printf("一共判断%d次",counts);
}
     /**
      * 放置第n个皇后
      * @param n
      */
   public void check(int n){
       if(n==max){
            print();
            return;
         }
     for (int i = 0; i <max ; i++) {
         //先把当前的皇后n放到该行第一列
          arr[n]=i;
          //判断是否冲突
          if(isClash(n)){
              check(n+1);
          }
     }
 }
 /**
 * 放置第n个皇后，是否与前面可以相互攻击
 * @param n  第几个皇后
 * @return
 */
 public boolean isClash(int n){
     counts++;
     for (int i = 0; i < n; i++) {
           //arr[i]==arr[n]判断是否同一列， Math.abs(n-i)==Math.abs(arr[n]-arr[i]判断是否同一斜线
           if(arr[i]==arr[n] || Math.abs(n-i)==Math.abs(arr[n]-arr[i])){
              return  false;
           }
     }
     return true;
 }
  //输出皇后摆放位置
    public void print(){
        count++;
        for (int i = 0; i <arr.length ; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

效果图：

可以看出，他要进行1万五千多次判断，效率比较低，后期可以结合一些相应的算法进行优化。著名的递归问题还有很多，汉诺塔，跳台阶。。这里就不举例了。