java代码实现迷宫问题 并且回溯相关路径!

package Queue;


import java.util.Arrays;
import java.util.Scanner;

public class findPathDemo02 {

    /**
     *  定义迷宫节点类型
     */
    private static class MazeNode {

        // 节点的值
        int val;
        // 节点的x和y坐标
        int x;
        int y;
        // 节点四个方向的行走状态，true表示可以走，false表示不能走
        boolean[] state;




        /**
         * 迷宫路径初始化
         */
        public MazeNode(int data, int i, int j){
            this.state = new boolean[4];  //上下左右四个状态！
            this.val = data;            //每一个点的数值 表示可不可以行走！
            this.x = i;                 //在迷宫中的对应的坐标值
            this.y = j;
        }

        @Override
        public String toString() {
            return "MazeNode{" +
                    "val=" + val +
                    ", x=" + x +
                    ", y=" + y +
                    ", state=" + Arrays.toString(state) +
                    '}';
        }
    }



    /**
     * 描述: 迷宫的类型定义
     */
    public static class Maze {
        // 迷宫所有的路径存储在二维数组当中
        private MazeNode[][] maze;
        // 存储迷宫路径节点的队列结构，采用层层扩张的方式，寻找迷宫最优的路径信息
        private LinkQueue<MazeNode> queue;
        // 记录迷宫路径节点的行走信息
        private MazeNode[] pathrecord;
        // 迷宫的行数
        private int row;
        // 迷宫的列数
        private int col;



        /**
         * 迷宫初始化
         */
        public Maze(int row, int col) {
            this.row = row;
            this.col = col;
            this.maze = new MazeNode[row][col];  //初始化棋盘
            this.queue=new LinkQueue<>();    //创建一个队列用于扩张
            this.pathrecord = new MazeNode[row*col];    //创建一个数组用来存放可能经过的路径信息
        }


        /**
         * 初始化指定位置的迷宫节点
         */
        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; //上下左右 如果值为0 则表示可以走 如果不是就不能走
                    }
                    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;
                    }
                }
            }
        }


        /**
         * 寻找迷宫路径
         */
        static int count=0;
        public void findMazePath(int beginx,int beginy) {


            if (maze[beginx][beginy].val != 0) {
                return;                        //默认初始的时候为00
            }


            queue.Insert(maze[beginx][beginy]);       //首先将它存入队列中
            while(!queue.isEmpty()){
                MazeNode top = queue.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;
                    queue.Insert(maze[x][y+1]);
                    pathrecord[x*col+y+1] = maze[x][y];       //将二维数组存放到一维数组中  按行存储
                    System.out.println(++count+"次右  "+x+"   "+y);
                }

                // 往下方向走
                if(maze[x][y].state[Constant.DOWN]){
                    maze[x][y].state[Constant.DOWN] = false;
                    maze[x+1][y].state[Constant.UP] = false;
                    queue.Insert(maze[x+1][y]);
                    pathrecord[(x+1)*col+y] = maze[x][y];
                    System.out.println(++count+"次下   "+x+"   "+y);
                }

                // 往左方向走
                if(maze[x][y].state[Constant.LEFT]){
                    maze[x][y].state[Constant.LEFT] = false;
                    maze[x][y-1].state[Constant.RIGHT] = false;
                    queue.Insert(maze[x][y-1]);
                    pathrecord[x*col+y-1] = maze[x][y];
                    System.out.println(++count+"次左   "+x+"   "+y);
                }
                // 往上方向走
                if(maze[x][y].state[Constant.UP]){
                    maze[x][y].state[Constant.UP] = false;
                    maze[x-1][y].state[Constant.DOWN] = false;
                    queue.Insert(maze[x-1][y]);
                    pathrecord[(x-1)*col+y] = maze[x][y];
                    System.out.println(++count+"次上   "+x+"   "+y);
                }

                queue.poll();
            }
        }


        /**
         * 打印迷宫路径搜索的结果
         */
        public void showMazePath(){

            if(pathrecord[row*col-1] == null){
                System.out.println("迷宫不存在有效路径");
            } else {
                int a = row-1;
                int b = col-1;
                System.out.println("====================");
                while(true){
                    maze[a][b].val = '*';
                    MazeNode node = pathrecord[a*col+b];
                   System.out.println(a+"     "+b);
                    if(node == null){
                        System.out.println("==");
                        break;
                    }
                    a = node.x;
                    b = node.y;
                }
                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 class MazeNode {
            // 节点的值
            int val;
            // 节点的x和y坐标
            int x;
            int y;
            // 节点四个方向的行走状态，true表示可以走，false表示不能走
            boolean[] state;

            /**
             * 迷宫路径初始化
          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();
        // 寻找迷宫路径
        System.out.println("请输入你想要开始的起始位置的下标：");
        int beginx=in.nextInt();
        int beginy=in.nextInt();
        maze.findMazePath(beginx,beginy);
        // 打印迷宫路径搜索的结果
        maze.showMazePath();
    }
}


/*
0  1  0  0 0
0  0  0  1 0
1  0  1  1 0
0  0  0  0 0
0  0  0  0 0
 */

/*
0 0 0 0 0 0 0 0 0 0
1 1 0 0 1 0 1 0 1 0
1 0 0 0 0 0 0 1 0 1
0 0 1 1 0 0 1 0 1 0
0 0 1 0 0 0 0 1 0 1
0 0 0 1 0 0 1 0 1 1
0 0 0 0 0 1 0 1 0 1
0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 1 0 0 0 0
 */

使用自己写的链队列！

package Queue;

public class LinkQueue<T> {

        // 指向头节点(队头)
        private Entry<T> front;
        // 指向尾节点(队尾)
        private Entry<T> rear;
        // 记录队列节点的个数
        private int count;

        /**
         * 初始化，front和rear都指向头节点
         */
        public LinkQueue(){
            this.front = this.rear = new Entry<>(null, null);  //新建的结点为空！
        }


        /**
         * 入队操作
         */
        public void Insert(T val){
            Entry<T> node = new Entry<>(val, null);
            this.rear.next = node;   //将现有的尾指针的值指向新的结点！ 连接操作！
            this.rear = node;         //将现在的尾指针所指方向更新到最末尾的结点也就是本身的结点！
            this.count++;             //链队的加长度加操作！
        }

        /**
         * 出队操作
         */
        public T poll(){
            T val = null;   //创建一个泛型用来存放出队的数据！
            if(this.front.next != null){
                val = this.front.next.data;  //取出数据
                this.front.next = this.front.next.next;  //更新头指针的指向方向！
                // 删除队列最后一个元素，要把rear指向front，队列才能判空
                if(this.front.next == null){
                    this.rear = this.front;   //出队如果是最后一个元素所需要的判断！
                }
                this.count--;
            }
            return val;
        }


        /**
        *取对头操作！（只查看 不取值）
         */
        public T peek(){
            T val = null;
            if(this.front.next != null){
                val = this.front.next.data;
            }
            return val;
        }

        /**
         * 判断队列空
         */
        public boolean isEmpty(){
            return this.front == this.rear;
        }

        /**
         * 返回队列元素的个数
         */
        public int size(){
            return this.count;
        }

        /**
         * 节点类型定义
         */
        static class Entry<T>{
            T data;                             //一个是数据域
            Entry<T> next;              //一个是指针 指向下一个元素

            public Entry(T data, Entry<T> next) {   //初始化条件为数据和指向指针
                this.data = data;
                this.next = next;
            }
        }
    }