【数据结构】递归，迷宫求解，八皇后问题

大家好，我是被白菜拱的猪。

一个热爱学习废寝忘食头悬梁锥刺股，痴迷于girl的潇洒从容淡然coding handsome boy。

一、写在前言

第一次知道递归这个概念的时候，是在学斐波那契数列，然后还有一次是老师让我们打印电脑文件夹的目录结构，那时候老师说自己调用自己，咦，自己调用自己是什么意思呢？甚是不解，那时候对代码一窍不通，连创建一个类都不会，还在想System.out.println()是什么，随着编程能力的提高，发现递归不仅仅解决斐波那契数列。对递归也也有了深一层次的理解。
那么随着我的脚步，来探究递归到底是个啥？

二、递归

（一）递归介绍

1、递归概念

简单的来说递归（recursion）就是自己调用自己，将一个复杂的问题分解成相同规模的小问题，从要解决的问题出发，一直分解成已知的小问题，然后逐级返回，直到得到最大求解问题的解，有去有回，假如没个停止的条件，一直调用自己就会出现stackoverflow。

另外与递归相似的还有一个迭代（iteration），迭代是基于已有的值利用递推公示去推出要解的值，递归是A调用A，迭代是A重复调用B，我们接触最简单运用跌倒的场景就是求1-100的和。

迭代可以转换为递归，递归不一定能转化为迭代。除了这两个概念，后面还会介绍一种算法思想，动态规划，我认为是对递归的一种升级。

2、递归调用机制（java）

在这里通过一个简单的打印问题的例子对递归调用机制进行叙述。

package com.codingboy.recursion;

/**
 * @author: ljl
 * @date: 2020/8/10 14:04
 * @description:
 */
public class RecursionTest {
    public static void main(String[] args) {
        test(4);
    }
    public static void test(int n) {
        if (n > 2) {
            test(n - 1);
        }
        System.out.println("n=" + n);
    }
}

运行机制：
在jvm中分为栈区堆区和常量区，每次执行一个方法时，就会开辟一个空间（栈帧），每个空间的变量时独立的。

步骤：
main方法就会在栈区创建一个栈帧，在这个空间中，执行到了test（4）方法就会为这个方法再次创建一个栈帧，直到n=2，执行完这个方法之后，这个栈帧出栈，然后执行栈顶的方法，这样下去，知道main方法中程序执行完毕，结束程序。

所以最后的打印结果是n=2，n=3，n=4。

3、解决的问题

• 各种数学问题如八皇后，汉诺塔，迷宫求解，阶乘问题
• 各种算法：快排，归并，二分查找，分治
• 各种使用到栈的问题，也可以使用递归

4、注意事项

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

递归一定要有个出口，就像while循环一定要有个退出条件一样。

（二）迷宫求解（递归）

1、问题描述

这里我们将问题简单化，不要求求得最短路径，而是找到一个路径即可，最短路径又涉及到最后的广度优先遍历和深度优先遍历。

talk is shit，show me the code。

2、代码实现

package com.codingboy.recursion;

/**
 * @author: ljl
 * @date: 2020/8/10 21:18
 * @description:
 */
public class Maze {

    public static void main(String[] args) {
        //地图初始化
        int[][] map = new int[6][5];
        //初始化路障,1代表路障
        for (int i = 0; i < 6; i++) {
            map[i][0] = 1;
            map[i][4] = 1;
        }
        for (int i = 0; i < 5; i++) {
            map[0][i] = 1;
            map[5][i] = 1;
        }
        map[2][1] = 1;
        //打印地图
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print(map[i][j] + "  ");
            }
            System.out.println();
        }
        findRoad(map,1,1);
        //打印地图
        System.out.println("----走完之后----");
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print(map[i][j] + "  ");
            }
            System.out.println();
        }
    }

    //map代表地图，i代表点的横坐标，j代表纵坐标,1-代表障碍，2-代表能走，3-代表走了但走不通
    public static boolean findRoad(int[][] map, int i,int j) {
        //递归，假如到了终点就退出
        if (map[4][3] == 2) {
            return true;
        }
        //找路,从下，左，上，右
        if(map[i][j] == 0) { //说明这条路没有走过
            //假设该点可以走
            map[i][j] = 2;
            //看其他方向是否能够走，能走就return true
            if (findRoad(map, i, j + 1)) {
                return true;
            } else if (findRoad(map, i + 1, j)) {
                return true;
            } else if (findRoad(map, i, j - 1)) {
                return true;
            } else if (findRoad(map, i - 1, j)) {
                return true;
            } else {
                //说明是死路走不通
                map[i][j] = 3;
                return false;
            }
        }
        return false;
    }

}

//找路

运行结果：

（三）八皇后问题

1、问题描述

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

2、求解思路

1. 第一个皇后先放第一行第一列
2. 第二个皇后放在第二行第一列、然后判断是否OK， 如果不OK，继续放在第二列、第三列、依次把所有列都放完，找到一个合适
3. 继续第三个皇后，还是第一列、第二列……直到第8个皇后也能放在一个不冲突的位置，算是找到了一个正确解
4. 当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到.
5. 然后回头继续第一个皇后放第二列，后面继续循环执行 1,2,3,4的步骤

说明：理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题. arr[8] = {0 , 4, 7, 5, 2, 6, 1, 3} //对应arr 下标 表示第几行，即第几个皇后，arr[i] = val , val 表示第i+1个皇后，放在第i+1行的第val+1列

3、代码实现

package com.codingboy.recursion;

import javax.swing.*;

/**
 * @author: ljl
 * @date: 2020/8/10 18:22
 * @description:
 */
public class EightQueen {
    //定义有多少个皇后
    int max = 8;
    //使用一维数组存储皇后的位置  array[i] = value; i代表行，value代表列，即(i,value)是皇后所在位置
    int[] array = new int[max];
    //记录有多少中情况
    static int count = 0;
    public static void main(String[] args) {
        EightQueen eightQueen = new EightQueen();
        eightQueen.check(0);
        System.out.println("有多少种情况：" + count);
    }
    //打印数组
    public void print() {
        //用来记录有多少种情况。
        count++;
        for (int i = 0; i < array.length ; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    //判断皇后是否满足位置，即是否在同一列或者在一斜线上
    public  boolean judge(int n) {
        for (int i = 0; i < n; i++) {
            //array[i] == array [n] 表示在同一列上
            //Math.abs(n - i) == Math.abs(array[n] = array[i])斜率为1，表示在同一斜线上
            if(array[i] == array [n] || Math.abs(n - i) == Math.abs(array[n] - array[i])) {
                return false;
            }
        }
        return true;
    }

    //开始放皇后
    public void check(int n) {
        if(n == max) { //说明8个皇后已经安排妥当,打印
            print();
            return;
        }

        //从第一列开始遍历
        for (int i = 0; i < max ; i++) {
            array[n] = i;
            if(judge(n)) { //如果该位置满足就放在这个位置，然后考虑下一行
                check(n+1);
            }
            //如果该位置不满足，就判断下一列
        }
    }
}

3、代码总结

首先从第一行第一列开始，判断是否满足，假如满足了就放第二个皇后，check就是放皇后，不满足就判断第二列是否满足。我们通过这个代码可以看到，递归的效率其实是不高的，92种方案，要进行一万多次判断。

三、结束语

学完之后，想起了社团里面教学弟学妹们递归，还是拿斐波那契数列举例，我们班的一个人说把数字跳到4000（不知道具体是几，让我试试）这不故意挑事嘛，当数字变大时，这个时间会非常非常的久，因为他每一次执行都要到基本条件。所以递归一不留神就会出现内存溢出的情况。

做人腻还是要低调，不要盲目的过于自信。也不要故意找别人茬，与人交往要真诚换真心。