JAVA数据结构05--递归

迷宫

public class MiGong10 {
    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;
        }

        //左右全置为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[1][2]=1;
     //   map[2][2]=1;

        //输出地图
        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);
        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();
        }

    }
//每一个格子都需要判断相同的条件，因此使用递归，最后退出递归的函数执行完毕返回到调用它的位置处，一路返回。
    private static boolean setWay(int[][] map, int i, int j) {
        if (map[6][5]==2){//递归结束条件
            return true;}
        if (map[i][j]==0){//0表示没走过的路
            map[i][j]=2;//假设当前格子可行，判断下 右上 左是否可行，满足哪一个可行哪一个设置为2，然后继续判断，直到遇到递归终止条件
  //递归调用一次就假设格子为2，判断四个方向的格子情况，避开走过的格子2或者墙1或者死路3，只要有一个方向是没有走过的格子，就走下去接着判断
            // 直到出口[6][5]处为2退出递归，一路返回true，所有设置为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;
        }

    }


}

八皇后

八皇后主要是回溯的理解，由于check是在for循环中递归的，当最后一个皇后位置确定且for循环也在最后一个索引处时，这个函数执行结束回退到上一个栈，上一行的皇后就向后移动一个位置，继续判断下一行的皇后可摆放位置，下一行皇后再轮一圈，确定解法，直到倒数第二行for循环遍历结束，回退到倒数第三行皇后继续移动…

public class Queen8 {
    static int count=0;
    static int judgecount=0;

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

    public static void main(String[] args) {
        Queen8 queen8 = new Queen8();
        queen8.check(0);//从第一个皇后开始放置
        System.out.println("解法次数：  "+count);
        System.out.println("判断次数：  "+judgecount);
    }

    //打印八皇后摆放位置的解法；
    public void print(){
        count++; //接成功就打印，因此解法加1
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();//打印完一个解法换行
    }

    //检测当前皇后与之前所有皇后的位置是否冲突：不在同一列也不在一个斜线
    public boolean judge(int n){
        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;
    }

    //放置第n个皇后
    public void check(int n) {
        if (n == max) {
            print();
            return;
        }

        for (int i = 0; i < max; i++) {
            array[n] = i;//第1个皇后放在第一列
            if (judge(n)) {
                //当前皇后跟之前皇后都不冲突，就放置第二个皇后去判断
                check(n + 1);
            }
            //如果冲突，就移动当前皇后，满足不冲突条件继续放置下一个皇后
        }
        //for循环结束表示皇后在这一行的位置都判断结束，此时函数执行结束，回溯上一行，继续移动上一行皇后来进行判断。
        //满足解法，就会打印解法，直到下一行for循环遍历结束。再次移动上一行皇后，直到for循环遍历结束，回退到上上一行...
    }
    }

本文地址：https://blog.csdn.net/qq_44241861/article/details/109631792