Java数据结构和算法（六）递归

最新推荐文章于 2024-07-27 13:31:57 发布

逆流者blog

最新推荐文章于 2024-07-27 13:31:57 发布

阅读量187

点赞数 1

分类专栏： # Java 数据结构与算法文章标签： java 算法

本文链接：https://blog.csdn.net/weixin_45847167/article/details/108584856

版权

Java 数据结构与算法专栏收录该内容

17 篇文章 2 订阅

订阅专栏

概念

递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂的问题,同时可以让代码变得简洁。

递归调用机制

下面用打印问题和阶乘问题来演示下递归

/**
 * @author wsh
 * @date 2020/9/15 5:09 下午
 * 递归问题
 */
public class RecursionTest {

    public static void main(String[] args) {
        test(4);
        System.out.println();
        int num = 4;
        int factorial = factorial(num);
        System.out.println(num + " factorial=" + factorial);
    }

    /**
     * 打印问题
     */
    public static void test(int n) {
        if (n > 1) {
            test(n - 1);
        }
        System.out.println("n=" + n);
    }

    /**
     * 阶乘问题
     */
    public static int factorial(int n) {
        if (n == 1) {
            return 1;
        } else {
            return factorial(n - 1) * n;
        }
    }
}

结果：

n=1
n=2
n=3
n=4

4 factorial=24

图解：
在这里插入图片描述
递归调用规则：

当程序执行到一个方法时，就会开辟一个独立的空间(栈)
每个空间的数据(局部变量)，是独立的。

迷宫问题

/**
 * @author wsh
 * @date 2020/9/15 5:17 下午
 * 迷宫问题，使用递归来解决
 */
public class Labyrinth {

    private static int count = 0;

    public static void main(String[] args) {
        // 用二位数组来模拟迷宫(8X7)
        int[][] data = new int[8][7];
        // 1表示墙
        // 上下设置为墙
        for (int i = 0; i < data[0].length; i++) {
            data[0][i] = 1;
            data[7][i] = 1;
        }
        // 左右设置为墙
        for (int i = 0; i < data.length; i++) {
            data[i][0] = 1;
            data[i][6] = 1;
        }
        // 设置挡板
        data[3][1] = 1;
        data[3][2] = 1;
        System.out.println("迷宫地图：");
        for (int[] datum : data) {
            for (int i : datum) {
                System.out.print(i + " ");
            }
            System.out.println();
        }
        // 使用递归回溯给小球找路
        setWay(data, 1,1);
        //setWay2(data, 1,1);
        System.out.println("走过的 迷宫地图：");
        for (int[] datum : data) {
            for (int i : datum) {
                System.out.print(i + " ");
            }
            System.out.println();
        }

        System.out.println("走路次数：" + count);
    }

    /**
     * 使用递归回溯来给小球找路
     * 说明：
     * 1、map 地图
     * 2、i，j表示从哪一个位置出发（1，1）为开始位置
     * 3、map[6][5] 是终点位置，到这个位置，表示路走通了
     * 4、map[i][j] 为0 表示没有走过，为1 表示墙，为2 表示已经走过
     * 5、走迷宫策略：下 -> 右 -> 上 -> 左
     */
    public static boolean setWay(int[][] map, int i, int j) {
        count++;
        if (map[6][5] == 2) {
            // 路走通了
            return true;
        } else {
            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;
            }
        }
    }

    /**
     * 使用递归回溯来给小球找路
     * 说明：
     * 1、map 地图
     * 2、i，j表示从哪一个位置出发（1，1）为开始位置
     * 3、map[6][5] 是终点位置，到这个位置，表示路走通了
     * 4、map[i][j] 为0 表示没有走过，为1 表示墙，为2 表示已经走过
     * 5、走迷宫策略：上 -> 左 -> 下 -> 右
     */
    public static boolean setWay2(int[][] map, int i, int j) {
        count++;
        if (map[6][5] == 2) {
            // 路走通了
            return true;
        } else {
            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;
            }
        }
    }
}

结果：

迷宫地图：
1 1 1 1 1 1 1 
1 0 0 0 0 0 1 
1 0 0 0 0 0 1 
1 1 1 0 0 0 1 
1 0 0 0 0 0 1 
1 0 0 0 0 0 1 
1 0 0 0 0 0 1 
1 1 1 1 1 1 1 
走过的 迷宫地图：
1 1 1 1 1 1 1 
1 2 0 0 0 0 1 
1 2 2 2 0 0 1 
1 1 1 2 0 0 1 
1 0 0 2 0 0 1 
1 0 0 2 0 0 1 
1 0 0 2 2 2 1 
1 1 1 1 1 1 1 
走路次数：15

八皇后问题(回溯算法)

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

图片来自百度
思路分析：

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

理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题.。

代码实现：

/**
 * @author wsh
 * @date 2020/9/21 2:19 下午
 * 8皇后问题
 */
public class Queue8 {

    private int max = 8;
    // 定义数组 array, 保存皇后放置位置的结果,比如 arr = {0 , 4, 7, 5, 2, 6, 1, 3}
    private int[] array = new int[max];

    private static int count = 0;

    private static int judgeCount = 0;

    public static void main(String[] args) {
        Queue8 queue8 = new Queue8();
        queue8.check(0);
        System.out.printf("一共有%d解法", count);
        System.out.println("判断冲突的次数：" + judgeCount);
    }

    /**
     * 放第 n 个皇后
     * check 是 每一次递归时，进入到 check 中都有 for(int i = 0; i < max; i++)，因此会有回溯
     * @param n
     */
    private void check(int n) {
        if (n == 8) {
            print();
            return;
        }
        for (int i = 0; i < max; i++) {
            array[n] = i;
            if (judge(n)) {
                check(n + 1);
            }
        }

    }

    /**
     * 判断放置的第n个皇后，是否和前面已摆放的皇后是否冲突
     *
     * @param n 第n个皇后
     * @return false 冲突，true 不冲突
     */
    private boolean judge(int n) {
        judgeCount++;
        /*
            array[i] == array[n] 表示判断 第 n 个皇后是否和前面的 n-1 个皇后在同一列
            Math.abs(n-i) == Math.abs(array[n] - array[i]) 表示判断第 n 个皇后是否和第 i 皇后是否在同一斜线
            判断是否在同一行, 没有必要，n 每次都在递增
        */
        for (int i = 0; i < n; i++) {
            if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])) {
                return false;
            }
        }
        return true;
    }


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

结果：

0 4 7 5 2 6 1 3 
0 5 7 2 6 3 1 4 
0 6 3 5 7 1 4 2 
0 6 4 7 1 3 5 2 
1 3 5 7 2 0 6 4 
1 4 6 0 2 7 5 3 
1 4 6 3 0 7 5 2 
1 5 0 6 3 7 2 4 
1 5 7 2 0 3 6 4 
1 6 2 5 7 4 0 3 
1 6 4 7 0 3 5 2 
1 7 5 0 2 4 6 3 
2 0 6 4 7 1 3 5 
2 4 1 7 0 6 3 5 
2 4 1 7 5 3 6 0 
2 4 6 0 3 1 7 5 
2 4 7 3 0 6 1 5 
2 5 1 4 7 0 6 3 
2 5 1 6 0 3 7 4 
2 5 1 6 4 0 7 3 
2 5 3 0 7 4 6 1 
2 5 3 1 7 4 6 0 
2 5 7 0 3 6 4 1 
2 5 7 0 4 6 1 3 
2 5 7 1 3 0 6 4 
2 6 1 7 4 0 3 5 
2 6 1 7 5 3 0 4 
2 7 3 6 0 5 1 4 
3 0 4 7 1 6 2 5 
3 0 4 7 5 2 6 1 
3 1 4 7 5 0 2 6 
3 1 6 2 5 7 0 4 
3 1 6 2 5 7 4 0 
3 1 6 4 0 7 5 2 
3 1 7 4 6 0 2 5 
3 1 7 5 0 2 4 6 
3 5 0 4 1 7 2 6 
3 5 7 1 6 0 2 4 
3 5 7 2 0 6 4 1 
3 6 0 7 4 1 5 2 
3 6 2 7 1 4 0 5 
3 6 4 1 5 0 2 7 
3 6 4 2 0 5 7 1 
3 7 0 2 5 1 6 4 
3 7 0 4 6 1 5 2 
3 7 4 2 0 6 1 5 
4 0 3 5 7 1 6 2 
4 0 7 3 1 6 2 5 
4 0 7 5 2 6 1 3 
4 1 3 5 7 2 0 6 
4 1 3 6 2 7 5 0 
4 1 5 0 6 3 7 2 
4 1 7 0 3 6 2 5 
4 2 0 5 7 1 3 6 
4 2 0 6 1 7 5 3 
4 2 7 3 6 0 5 1 
4 6 0 2 7 5 3 1 
4 6 0 3 1 7 5 2 
4 6 1 3 7 0 2 5 
4 6 1 5 2 0 3 7 
4 6 1 5 2 0 7 3 
4 6 3 0 2 7 5 1 
4 7 3 0 2 5 1 6 
4 7 3 0 6 1 5 2 
5 0 4 1 7 2 6 3 
5 1 6 0 2 4 7 3 
5 1 6 0 3 7 4 2 
5 2 0 6 4 7 1 3 
5 2 0 7 3 1 6 4 
5 2 0 7 4 1 3 6 
5 2 4 6 0 3 1 7 
5 2 4 7 0 3 1 6 
5 2 6 1 3 7 0 4 
5 2 6 1 7 4 0 3 
5 2 6 3 0 7 1 4 
5 3 0 4 7 1 6 2 
5 3 1 7 4 6 0 2 
5 3 6 0 2 4 1 7 
5 3 6 0 7 1 4 2 
5 7 1 3 0 6 4 2 
6 0 2 7 5 3 1 4 
6 1 3 0 7 4 2 5 
6 1 5 2 0 3 7 4 
6 2 0 5 7 4 1 3 
6 2 7 1 4 0 5 3 
6 3 1 4 7 0 2 5 
6 3 1 7 5 0 2 4 
6 4 2 0 5 7 1 3 
7 1 3 0 6 4 2 5 
7 1 4 2 0 6 3 5 
7 2 0 5 1 4 6 3 
7 3 0 2 5 1 6 4 
一共有92解法判断冲突的次数：15720