Java代码 - 基于深度优先遍历实现迷宫路径搜索

本文介绍用Java语言实现迷宫路径的深度优先搜索，采用非递归代码实现，找一条从左上角节点到右下角节点的可通行的路径信息，如果路径存在，打印出路径信息，否则打印迷宫不存在可同行的路径。另外代码只实现了迷宫路径搜索的算法，没有添加图形界面的实现。

深度优先遍历迷宫路径，是在每一个节点都按照固定的方向往下一个节点行走，在遍历的过程中，除非该方向走不通，否则是不会检查节点其它方向的可行走状态，代码运行如下：

请输入迷宫的行列数:5 5
请输入迷宫路径
0 0 1 1 1 
1 0 0 1 1
1 1 0 0 1
1 1 0 0 1
1 1 0 0 0
迷宫路径搜索结果如下：
* * 1 1 1 
1 * * 1 1 
1 1 * * 1 
1 1 0 * 1 
1 1 0 * * 

常量定义

/**
 * 描述: 把代码中所有出现的常量在这里统一定义
 * @Author administrator
 * @Date 5/18
 */
public interface Constant {
    // 右方向
    int RIGHT = 0;
    // 下方向
    int DOWN = 1;
    // 左方向
    int LEFT = 2;
    // 上方向
    int UP = 3;
}

迷宫节点类型定义

该迷宫采用栈实现非递归路径搜索，可以直接使用Java集合LinkedList，这里是自定义一个链式栈结构，代码如下：

/**
 * 描述:实现迷宫路径搜索需要的链式栈结构
 */
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> node = new Entry<>(val, this.top.next);
        this.top.next = node;
    }

    /**
     * 出栈操作
     * @return
     */
    public T pop(){
        T val = null;
        if(this.top.next != null){
            val = this.top.next.data;
            this.top.next = this.top.next.next;
        }
        return val;
    }

    /**
     * 查看栈顶元素
     * @return
     */
    public T peek(){
        T val = null;
        if(this.top.next != null){
            val = this.top.next.data;
        }
        return val;
    }

    /**
     * 判断栈空
     * @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;
        }
    }
}

迷宫类定义

这里主要包含了迷宫节点类MazeNode和迷宫类型Maze，代码如下：

/**
 * 描述: 迷宫的类型定义
 */
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<col-1 && this.maze[i][j+1].val == 0){
                    this.maze[i][j].state[Constant.RIGHT] = true;
                }

                if(i<row-1 && this.maze[i+1][j].val == 0){
                    this.maze[i][j].state[Constant.DOWN] = true;
                }

                if(j>0 && this.maze[i][j-1].val == 0){
                    this.maze[i][j].state[Constant.LEFT] = true;
                }

                if(i>0 && this.maze[i-1][j].val == 0){
                    this.maze[i][j].state[Constant.UP] = true;
                }
            }
        }
    }

    /**
     * 寻找迷宫路径
     */
    public void findMazePath() {
        if(maze[0][0].val == 1){
            return;
        }

        stack.push(maze[0][0]);
        while(!stack.isEmpty()){
            MazeNode top = stack.peek();
            int x = top.x;
            int y = top.y;
            if(x == row-1 && y == col-1){
                return;
            }

            // 往右方向走
            if(maze[x][y].state[Constant.RIGHT]){
                maze[x][y].state[Constant.RIGHT] = false;
                maze[x][y+1].state[Constant.LEFT] = false;
                stack.push(maze[x][y+1]);
                continue;
            }

            // 往下方向走
            if(maze[x][y].state[Constant.DOWN]){
                maze[x][y].state[Constant.DOWN] = false;
                maze[x+1][y].state[Constant.UP] = false;
                stack.push(maze[x+1][y]);
                continue;
            }

            // 往左方向走
            if(maze[x][y].state[Constant.LEFT]){
                maze[x][y].state[Constant.LEFT] = false;
                maze[x][y-1].state[Constant.RIGHT] = false;
                stack.push(maze[x][y-1]);
                continue;
            }

            // 往上方向走
            if(maze[x][y].state[Constant.UP]){
                maze[x][y].state[Constant.UP] = false;
                maze[x-1][y].state[Constant.DOWN] = false;
                stack.push(maze[x-1][y]);
                continue;
            }

            stack.pop();
        }
    }

    /**
     * 打印迷宫路径搜索的结果
     */
    public void showMazePath() {
        System.out.println("迷宫路径搜索结果如下：");
        if(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('*' + " ");
                    } else {
                        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 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();
}

问题

深度遍历无法寻找最短的迷宫路径，如下运行代码：

请输入迷宫的行列数:5 5
请输入迷宫路径
0 0 1 1 1 
1 0 0 0 0
1 0 0 0 0
1 1 0 1 1
1 1 0 0 0
迷宫路径搜索结果如下：
* * 1 1 1 
1 * * * * 
1 0 * * * 
1 1 * 1 1 
1 1 * * * 

很明显上面找的路径不是最短的迷宫路径，参考另一篇通过广度优先遍历找迷宫最短路径的代码演示。