递归又是什么？？

递归

递归的概念

简单的说：递归就是方法自己调用自己，每次调用的时候传入不通的变量，递归有利于编程者解决复杂的问题，同时让代码变得简单。

递归的调用机制

递归能解决什么样的问题

1. 八皇后问题、汉诺塔、阶乘问题、迷宫问题、球和蓝球的问题等
2. 快排，归并排序、二分查找、分治算法等
3. 使用栈解决的问题 --》 递归

递归需要遵守的规则

1. 执行一个方法的时候，就会创建一个受保护的独立的空间
2. 方法的局部变量是独立的，不会受到相互之间的影响，比如 n 变量
3. 如果方法中使用的是引用类型变量（比如数组）就会共享该引用类型的数据
4. 递归必须向退出递归的条件逼近，否则就是无限递归，会出现 StackOverflowError
5. 当一个方法执行完毕的时候，或者遇到了return 就会返回，遵守 谁调用，结果给谁 同时当方法执行完毕或者返回，该方法也就会执行完毕。

递归 - 迷宫问题

代码实现

package recursion;

import java.util.Arrays;

/**
 * @author ProMonAn
 * @create 2020-11-30 20:30
 */
public class MiGong {


    public static void main(String[] args) {

        // 创建迷宫


        int[][] map = new int[8][7];
        // 使用 1 表示墙
        for (int i = 0; i < 7; i++) {
            map[0][i] = 1;
            map[7][i] = 1;
        }
        for (int i = 0; i < 8; i++) {
            map[i][0] = 1;
            map[i][6] = 1;
        }
        map[3][1] = 1;
        map[3][2] = 1;

        // 输出地图
        for (int i = 0; i < map.length; i++) {
            System.out.println(Arrays.toString(map[i]));
        }

        // 使用递归回溯给小球找到出路
        setWay(map,1,1);


        // 输出走过的地图
        for (int i = 0; i < map.length; i++) {
            System.out.println(Arrays.toString(map[i]));
        }

    }

    /**
     *
     * @param map 迷宫
     * @param i  起始位置
     * @param j  起始位置
     * @return  返回是否找到
     *
     * 0 表示未走过  1 墙体  2  通  3  走过不通
     *
     */
    public static boolean setWay(int[][] map,int i , int j){
        if (map[map.length-2][map[0].length-2] == 2){
            return true;
        }
        if (map[i][j] == 0){
            // 按照策略走  下  右  上  左
            map[i][j] = 2;
            if (setWay(map,i+1,j)){
                return true;
            }else if (setWay(map,i,j+1)){
                return true;
            }else if (setWay(map,i-1,j)){
                return true;
            }else if (setWay(map,i,j-1)){
                return true;
            }else {
                map[i][j] = 3;
                return false;
            }

        }else {
            return false;
        }
    }


}

递归-八皇后问题（回溯算法）

![在这里插入图片描述](https://img-blog.csdnimg.cn/20201201011420499.png

代码实现

package recursion;

/**
 * @author ProMonAn
 * @create 2020-12-01 0:46
 */
public class Queue8 {

    int max = 8;
    int[] array = new int[max];

    static int count = 0;
    static int judeCount = 0;

    public static void main(String[] args) {

        Queue8 queue8 = new Queue8();
        queue8.check(0);
        System.out.println(count);
        System.out.println(judeCount);

    }

    private void check(int n){
        if (n == max){
            print();
            return;
        }
        for (int i = 0; i < max; i++) {
            array[n] = i;
            if (judge(n)){
                check(n+1);
            }
        }
    }

    // 查看当我们放置第n个皇后的时候是否发生冲突
    private boolean judge(int n){
        judeCount++;
        for (int i = 0; i < n; i++) {
            if (array[i] == array[n] || (Math.abs(array[i]-array[n]) == Math.abs(i - n))){
                return false;
            }
        }
        return true;
    }

    private void print(){
        count++;
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+"");
        }
        System.out.println();
    }




}