迷宫小游戏

* 功能描述 1.提示输入迷宫的行列数：6  6
* 2.请输入迷宫的路径信息
0 0 1 1 1 1
1 0 0 0 1 1
1 0 1 1 1 1
1 0 1 1 1 1
1 0 1 1 1 1
1 0 0 0 0 0
* 搜索迷宫路径...
* 3.打印“迷宫不存在有效路径”
*/

根据迷宫的特点，找路径。

1.需要创建一个二维数组存储每个节点的位置信息，还需要知道每一个节点的值是1或者0，还需要判断该节点上、下、左、右是否能走，
所以一个简单的二维数组不能满足需求；此时需要建立一个Node[]类，来存储迷宫的节点信息。

class Node{
int x;int y;//节点的横纵坐标
int val;//每个节点的值
boolean right;boolean left;boolean down;boolean up;//四个方向
//构造方法为变量初始化
public Node(int x,int y,int data){
this.x=x;
this.y=y
this.data=datal;
   }
}

2.根据迷宫寻找路径的特点，若找到一个点行不通，则应该退回上一节点继续寻找。根据这种特点，需要一个栈结构来进行迷宫路径的寻找。最后根据入栈的节点值，依据横纵坐标来判断路径。按照先看右边，再下方，再上，再左的顺序查找。

需要的属性及方法

属性：节点的坐标、节点值 用一个Node类型的数组来存储，栈顶指针

方法：出栈、入栈、判断栈满栈空、栈的长度 、返回栈顶元素

class Stack{
Node[] array;
int top;
public Stack(){  //构造函数
this.array=new Node[10];
this.top=0;}
public void push(Node node){
        if(full()){
            this.array=Arrays.copyOf(this.array,this.array.length * 2);
        }
        this.array[this.top]=node;
        this.top++;
    }

    // 出栈
    public void pop(){
        this.top--;
    }

    // 返回栈顶元素
    public Node top(){
        return this.array[this.top-1];
    }

    // 判断栈空
    public boolean empty(){
        return this.top==0;
    }

    // 判断栈满
    public boolean full(){
        return this.array.length==this.top;
    }
}

 3.迷宫类，用来判断节点的上下左右是否能走,以及输出路径

class Maze{
private int row;
private int col;
private Node[][] maze;//二维数组，存储迷宫节点
private Stack stack;//栈结构，寻找迷宫路径用

//构造函数
public Maze(){
    this(8,8);
}
//根据属性进行构造函数
public Maze(int row,int col){
    this.row=row;
    this.col=col;
    this.maze=new Node[this.row][this.col];
    this.stack=new Stack();//引用变量new
}
//设置节点的初值，把节点的值、横纵坐标赋给maze数组
public setMazeNode(int data,int i,int j){this.maze[i][j]=new Node(data,i,j);}/**
 /* 生成节点的坐标和值
 * 设置迷宫每一个节点的四个方向的行走状态
 */
public void setMazeNodeState(){
for(int i=0;i<row;i++){
　　for(int j=0;j<col;j++){
   if(maze[i][j]==1){continue;}
　　//调整节点的右方向
　　if(j<col-1&&maze[i][j+1]==0){
　　this.maze[i][j].right=true;}
　　//下方向
　　if(i<row-1&&maze[i+1][j]==0){
　　this.maze[i][j].down=true;
   //左方向
   if(j>0&&this.maze[i][j-1].data==0){
   this.maze[i][j].left=true;}
   //上方向
   if(i>0 &&this.maze[i-1][j].data==0){
   this.maze[i][j].up=true;}
   }
  }
 }
}
//寻找迷宫路径
public void findMazePath(){
    /**
     * 逻辑：如果当前栈顶节点的右方节点是0，则先把右方的节点压入栈；如果该节点的下方节点是0，若没有，再找左边的节点。
     * 如果都没有，则出栈当前节点，再找栈顶节点的右、下、左
     */
    if((this.maze[0][0].data==1)||(this.maze[this.row-1][this.col-1].data==1)){
       return;
    }
    this.stack.push(this.maze[0][0]);
    while(!this.stack.empty()){
        //获取栈顶节点
        Node node=this.stack.top();
        //栈顶节点就是出口节点，迷宫路径搜索完成了
        if(node.x==row-1&&node.y==col-1){
            return;
        }
        if(node.right){//右方向可以走
            this.maze[node.x][node.y].right=false;//将当前节点的右方向置为false
            this.maze[node.x][node.y+1].left=false;//将右边节点的左边置为不能走
            this.stack.push(this.maze[node.x][node.y+1]);
            continue;//返回循环的开始继续循环
        }
        if(node.down){
            this.maze[node.x][node.y].down=false;//将当前节点的下方向置为false;
            this.maze[node.x+1][node.y].up=false;//将下边节点的上边置为不能走
            this.stack.push(this.maze[node.x+1][node.y]);
            continue;
        }
        if(node.left){
            this.maze[node.x][node.y].left=false;//将当前节点的左方向置为false
            this.maze[node.x][node.y-1].right=false;//将左边节点的右边置为不能走
            this.stack.push(this.maze[node.x][node.y-1]);
            continue;
        }
        if(node.up){
            this.maze[node.x][node.y].up=false;//将当前节点的上方向置为false;
            this.maze[node.x-1][node.y].down=false;//将上边节点的下边置为不能走
            this.stack.push(this.maze[node.x-1][node.y]);
            continue;
        }
        this.stack.pop();
    }
}
public void showMazePath(){
         if(stack.empty()){
             System.out.println("未找到迷宫的有效路径");
         }else{
             /*
             若栈不空，说明找到了迷宫路径，将栈中元素出栈，将*赋给出栈元素，然后再继续遍历栈内元素
              */
             while(!this.stack.empty()){
                 Node node=this.stack.top();
                 this.maze[node.x][node.y].data='*';
                 this.stack.pop();
             }
             /*
             遍历二维数组，如果二维数组中的值为*，则打印出*，否则打印数据
              */
             for(int i=0;i<row;i++){
                 for(int j=0;j<col;j++){
                     if(this.maze[i][j].data=='*'){
                         System.out.print('*'+" ");
                     }else{
                         System.out.print(this.maze[i][j].data+" ");
                     }
                 }
                 System.out.println();
             }
         }
     }
}

4.主类，用来设置二维数组，实现题型哪一方下等功能

public  class Mainn{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.print("请输入迷宫的行列数:");
        int row = in.nextInt();
        int col = in.nextInt();

        // 用row和col生成迷宫对象
        Maze maze = new Maze(row, col);

        System.out.println("请输入迷宫的路径信息:");
        for(int i=0; i<row; ++i){
            for(int j=0; j<col; ++j){
                int data = in.nextInt();
                // data i j
                maze.setMazeNode(data, i, j);
            }
        }

        // 设置迷宫每一个节点的四个方向的行走状态
        maze.setMazeNodeState();

        // 开始寻找迷宫路径
        maze.findMazePath();

        // 输出迷宫路径结果
        maze.showMazePath();
    }
}