递归的概念

递归的概念

递归：通俗的来说，递归就是自己调用自己，每次调用的时候传入不同的参量。

递归调用的机制

递归就是自己调用自己，每次调用的时候传入不同的参量，然后向退出递归的条件逼近。

代码实现

package com.datestructures.recursion;

public class RecursionTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //通过打印问题回顾递归调用机制
        test(4);

        //int res = factorial(3);
        //System.out.println("res=" + res);
    }

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

递归-迷宫问题

代码实现

package com.datestructures.recursion;

public class MiGong {
    public static void main(String[] args) {
        //初始化迷宫
        int[][] map = new int[8][7];
        //上下城墙
        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;
        /*
        体现回溯就让他找不到
        map[3][3] = 1;
        map[3][4] = 1;
        map[3][5] = 1;
        */
        System.out.println("初始化地图为");
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
        //setWay(map, 1, 1);
        setWay2(map, 1, 1);
        System.out.println("小球走过的路径地图为");
        System.out.println("初始化地图为");
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }

    /**
     * @param map 地图共享
     * @param i   初始位置
     * @param j
     * @return 如果找到通路返回true, 否则返回false
     * 当小球到达map[6][5]就认为小球找到通路
     * 制定规则：0 表示小球没走过，可以走   1 表示挡板  2  表示小球走过的路径   3表示小球走过但是此路不通的路径
     * 寻找路径规则  先向下走，不通向右，不通向上，不通向左
     * 使用递归完成
     */
    //给小球找通路
    public static boolean setWay(int[][] map, int i, int j) {
        //先表示找到路径
        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 {//map[i][j]!=0  表示当前位置为 1 或 2 或 3
                return false;
            }
        }

    }

    //寻找路径规则  先向下走，不通向右，不通向上，不通向左
    //使用递归完成
    public static boolean setWay2(int[][] map, int i, int j) {
        //先表示找到路径
        if (map[6][5] == 2) {
            return true;
        } else {
            if (map[i][j] == 0) {//表示当前位置没有走过
                map[i][j] = 2;
                if (setWay2(map, i - 1, j)) {//向上走
                    return true;
                } else if (setWay2(map, i, j + 1)) {//向右走
                    return true;
                } else if (setWay2(map, i + 1, j)) {//向下走
                    return true;
                } else if (setWay2(map, i, j - 1)) {//向左走
                    return true;
                } else {
                    map[i][j] = 3;//说明当前位置走不通是死路
                    return false;
                }
            } else {//map[i][j]!=0  表示当前位置为 1 或 2 或 3
                return false;
            }
        }
    }
}

八皇后问题

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

八皇后小游戏网站：http://www.7k7k.com/swf/49842.htm

思路分析

1.第一个皇后先放第一行第一列

2.第二个皇后放在第二行第一列、然后判断是否OK， 如果不OK，继续放在第二列、第三列、依次把所有列都放完，找到一个合适

3.继续第三个皇后，还是第一列、第二列……直到第8个皇后也能放在一个不冲突的位置，算是找到了一个正确解

4.当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到.

5.然后回头继续第一个皇后放第二列，后面继续循环执行 1,2,3,4的步骤

6.示意图

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

例如：arr[8] = {0 , 4, 7, 5, 2, 6, 1, 3}

对应arr 下标 表示第几行，即第几个皇后，arr[i] = val , val 表示第i+1个皇后，放在第i+1行的第val+1列

代码实现

package com.datestructures.recursion;

public class Queue8 {
    //八皇后问题
    int max = 8;
    int[] array = new int[max];
    static int judgecount = 0;//总共判断冲突次数
    static int count = 0;//总共有count钟摆法
    public static void main(String[] args) {
        Queue8 queue8 =new Queue8();
        queue8.check(0);
        System.out.println("总共有"+count+"种摆法");
        System.out.println("总共判断冲突了"+judgecount+"次");
    }

    /**
     *
     * @param n 放置第n个皇后
     */
    private void check(int n){
        if(n==max){ //n==8 表明8个皇后早已放好
            print();
            return;
        }
        //依次放入皇后，判断是否冲突
        for (int i = 0; i < max; i++) {
            //先把第n个皇后，放到该行的第一列
            array[n] = i;
            //判断第n个皇后放到i列时，是否冲突
            if(judge(n)){//不冲突
                //接着放下一个皇后
                check(n+1);
            }
            //如果冲突，就会移到下一列，继续放置，继续判断
        }

    }
    /**
     * 判断当前位置是否和前面的位置冲突
     * @param n 表示第几个皇后
     * @return 如果不冲突就返回true  如果冲突返回false
     */
    private boolean judge(int n){
        /**
         * 说明
         * 1.array[i]==array[n] 判断第n个皇后是否和第i个皇后在同一列
         * 2.Math.abs(n-i)==Math.abs(array[n]-array[i]) 判断第n个皇后是否和第i个皇后在同一斜线
         * 3.对于判断是否同一行这里没有判断的必要，因为每放置一个皇后就会在下一行摆放皇后
         */
        judgecount++;
        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();
    }
}