zoukankan      html  css  js  c++  java
  • Java迷宫代码,深度优先遍历

    此次迷宫深度优先遍历寻找路径采用栈结构,每个节点都有固定的行走方向(右下左上),除非一个方向走不通,不然会一条道走到黑。

    如果路径存在,打印出行走路径,否则打印出迷宫不存在有效路径。

    方向常量定义:

    public interface Constant {
        // 右方向
        int RIGHT = 0;
        // 下方向
        int DOWN = 1;
        // 左方向
        int LEFT = 2;
        // 上方向
        int UP = 3;
    }

    所用到的栈定义(jdk自带的栈或集合也可以实现此功能)

    /**
     * 描述:实现迷宫路径搜索需要的链式栈结构
     *
     * @Author shilei
     * @Date 2019/5/18
     */
    public class Stack<T> {
        
        // top指向头节点,头节点的后面就是栈顶节点
        private Entry<T> top;
    
        public Stack() {
            this.top =new Entry<>(null,null);
        }
    
        /**
         * 入栈操作
         * @param val
         */
        public void push(T val){
            Entry<T> newEntry=new Entry<>(val,this.top.next);
            this.top.next=newEntry;
        }
    
        /**
         * 出栈操作
         * @return
         */
        public T pop(){
            Entry<T> entry=this.top.next;
            this.top.next=this.top.next.next;
            return entry.data;
        }
    
        /**
         * 查看栈顶元素
         * @return
         */
        public T peek(){
            if(isEmpty())return null;
            return this.top.next.data;
        }
    
        /**
         * 判断栈空
         * @return
         */
        public boolean isEmpty(){
            return this.top.next==null;
        }
    
        /**
         * 节点类型定义
         * @param <T>
         */
        static class Entry<T>{
            T data;
            Entry<T> next;
    
            public Entry(T data, Entry<T> next) {
                this.data = data;
                this.next = next;
            }
        }
    }

    迷宫节点类型定义

        /**
         * 描述: 定义迷宫节点类型
         */
        private static class MazeNode {
            // 节点的值
            int val;
            // 节点的x和y坐标
            int x;
            int y;
            // 节点四个方向的行走状态,true表示可以走,false表示不能走
            boolean[] state;
    
            /**
             * 迷宫路径初始化
             * @param data
             * @param i
             * @param j
             */
            public MazeNode(int data, int i, int j){
                this.state = new boolean[4];
                this.val = data;
                this.x = i;
                this.y = j;
            }
        }

    迷宫类型定义

    /**
     * 描述: 迷宫的类型定义
     *
     * @Author shilei
     * @Date 2019/5/18
     */
    public class Maze {
        // 迷宫所有的路径存储在二维数组当中
        private MazeNode[][] maze;
    
        // 存储迷宫路径节点的栈 深度优先
        private Stack<MazeNode> stack;// 迷宫的行数
        private int row;
        // 迷宫的列数
        private int col;
    
        /**
         * 迷宫初始化
         * @param row
         * @param col
         */
        public Maze(int row, int col) {
            this.row = row;
            this.col = col;
            this.maze = new MazeNode[row][col];
            this.stack = new Stack<>();
        }
    
    
        /**
         * 初始化指定位置的迷宫节点
         * @param data
         * @param i
         * @param j
         */
        public void initMazeNode(int data, int i, int j) {
            this.maze[i][j] = new MazeNode(data, i, j);
        }
    
        /**
         * 修改迷宫所有节点四个方向的行走状态信息
         */
        public void initMazeNodePathState() {
            for (int i=0;i<row;i++){
                for (int j=0;j<col;j++){
                    if(j+1<col&&maze[i][j+1].val==0){
                        maze[i][j].state[Constant.RIGHT]=true;
                    }
                    if(i+1<row&&maze[i+1][j].val==0){
                        maze[i][j].state[Constant.DOWN]=true;
                    }
                    if(j>0&&maze[i][j-1].val==0){
                        maze[i][j].state[Constant.LEFT]=true;
                    }
                    if(i>0&&maze[i-1][j].val==0){
                        maze[i][j].state[Constant.UP]=true;
                    }
                }
            }
        }
    
        /**
         * 寻找迷宫路径
         */
        public void findMazePath() {
    // 深度优先
            if (maze[0][0].val != 0) {
                return;
            }
            stack.push(maze[0][0]);
            while (!stack.isEmpty()) {
                MazeNode top = stack.peek();
                //找到出口
                if (top.x == row - 1 && top.y == col - 1) {
                    break;
                }
                if (top.state[Constant.RIGHT]) {
                    top.state[Constant.RIGHT] = false;
                    stack.push(maze[top.x][top.y + 1]);
                    this.stack.peek().state[Constant.LEFT] = false;
                    continue;
                }
                if (top.state[Constant.DOWN]) {
                    top.state[Constant.DOWN] = false;
                    stack.push(maze[top.x + 1][top.y]);
                    this.stack.peek().state[Constant.UP] = false;
                    continue;
                }
                if (top.state[Constant.LEFT]) {
                    top.state[Constant.LEFT] = false;
                    stack.push(maze[top.x][top.y - 1]);
                    this.stack.peek().state[Constant.RIGHT] = false;
                    continue;
                }
                if (top.state[Constant.UP]) {
                    top.state[Constant.UP] = false;
                    stack.push(maze[top.x - 1][top.y]);
                    this.stack.peek().state[Constant.DOWN] = false;
                    continue;
                }
                stack.pop();
            }
        }
        /**
         * 打印迷宫路径搜索的结果
         */
        public void showMazePath(){
            if(this.stack.isEmpty()){
                System.out.println("迷宫出不去咯");
            }else {
                while (!stack.isEmpty()){
                    MazeNode top=stack.pop();
                    maze[top.x][top.y].val='*';
                }
                for (int i = 0; i <row ; i++) {
                    for (int j = 0; j <col ; j++) {
                        if(maze[i][j].val=='*'){
                            System.out.print("*"+" ");
                           continue;
                        }
                        System.out.print(maze[i][j].val+" ");
                    }
                    System.out.println();
                }
            }
        }
    
        /**
         * 描述: 定义迷宫节点类型
         */
        private static class MazeNode {
            // 节点的值
            int val;
            // 节点的x和y坐标
            int x;
            int y;
            // 节点四个方向的行走状态,true表示可以走,false表示不能走
            boolean[] state;
    
            /**
             * 迷宫路径初始化
             * @param data
             * @param i
             * @param j
             */
            public MazeNode(int data, int i, int j){
                this.state = new boolean[4];
                this.val = data;
                this.x = i;
                this.y = j;
            }
        }
    }

    测试类

    public class Main {
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            System.out.print("请输入迷宫的行列数:");
            int row, col, data;
            row = in.nextInt();
            col = in.nextInt();
    
            Maze maze = new Maze(row, col);
    
            System.out.println("请输入迷宫路径");
            for (int i = 0; i < row; i++) {
                for (int j = 0; j < col; j++) {
                    data = in.nextInt();
                    maze.initMazeNode(data, i, j);
                }
            }
    
            // 修改迷宫所有节点四个方向的行走状态信息
            maze.initMazeNodePathState();
            // 寻找迷宫路径
            maze.findMazePath();
            // 打印迷宫路径搜索的结果
            maze.showMazePath();
    
        }
    }

    结果:

    请输入迷宫的行列数:4 5
    请输入迷宫路径
       0  1  0  0 0
       0  0  0  1 0
       1  0  1  1 0
       0  0  0  0 0
    
    * 1 * * * 
    * * * 1 * 
    1 0 1 1 * 
    0 0 0 0 * 

    缺点:深度优先无法求出迷宫最短路径,下一篇广度优先遍历可以求出最短路径。

  • 相关阅读:
    leetcode 350. Intersection of Two Arrays II
    leetcode 278. First Bad Version
    leetcode 34. Find First and Last Position of Element in Sorted Array
    leetcode 54. Spiral Matrix
    leetcode 59. Spiral Matrix II
    leetcode 44. Wildcard Matching
    leetcode 10. Regular Expression Matching(正则表达式匹配)
    leetcode 174. Dungeon Game (地下城游戏)
    leetcode 36. Valid Sudoku
    Angular Elements
  • 原文地址:https://www.cnblogs.com/jiezai/p/11067842.html
Copyright © 2011-2022 走看看