Java面向对象 -- 迷宫

题目：如图所示是一迷宫，“0”表示路，“1”表示墙，只有路可以走，入口为左上角，出口为右下角，请用面向对象的思想找出迷宫的路。

包结构

Constant 类

package com.tulun.constant;

public class Constant {
    public static final int UP = 0;//上
    public static final int DOWN = 1;//下
    public static final int LEFT = 2;//左
    public static final int RIGHT = 3;//右

    public static final boolean GOABLE = true;//可以走
    public static final boolean NotGOABLE = false;//不可以走

}

Maze 类

package com.tulun.dao;

import com.tulun.constant.Constant;
import com.tulun.util.MySqStackUtil;

/**
 * 迷宫类
 */
public class Maze {
    //行数
    private int row;
    //列数
    private int col;
    //结点类型的二维数组
    private MazeNode[][] mazeNodes;
    //栈对象
    MySqStackUtil mySqStackUtil;
    //初始化行、列、结点数组
    public Maze(int row,int col){
        this.row = row;
        this.col = col;
        mazeNodes = new MazeNode[row][col];
    }

    public void setMazeNodes(int x,int y,int val){

        mazeNodes[x][y] = new MazeNode(x,y,val);
    }

    /**
     * 现在二维数组里面，已经存放了迷宫的路径，开始记录每个节点
     * 四周的可走状态
     */
    public void judgePath() {
        mySqStackUtil = new MySqStackUtil();
        for(int i = 0;i < mazeNodes.length;i++){
            for(int j = 0;j < mazeNodes[i].length;j++){
                if(mazeNodes[i][j].getVal() == 0){
                    //上
                    if(i-1 >= 0 && mazeNodes[i-1][j].getVal() == 0){
                        mazeNodes[i][j].setPathState(Constant.UP,Constant.GOABLE);
                    }
                    //下
                    if(i+1 < row && mazeNodes[i+1][j].getVal() == 0){
                        mazeNodes[i][j].setPathState(Constant.DOWN,Constant.GOABLE);
                    }
                    //左
                    if(j-1 >= 0 && mazeNodes[i][j-1].getVal() == 0){
                        mazeNodes[i][j].setPathState(Constant.LEFT,Constant.GOABLE);
                    }
                    //右
                    if(j+1 < col && mazeNodes[i][j+1].getVal() == 0){
                        mazeNodes[i][j].setPathState(Constant.RIGHT,Constant.GOABLE);
                    }
                }
            }
        }
    }

    /**
     * 开始走迷宫，如果可以走
     * 把最后路径放到栈当中
     */
    public void goMaze() {
        //将入口压栈
        if(mazeNodes[0][0].getVal() == 0){
            mySqStackUtil.push(mazeNodes[0][0]);
        }
        //栈不为空时
        while(!mySqStackUtil.isEmpty()){
            //获得栈顶元素
            MazeNode gTop = mySqStackUtil.getTop();
            //栈顶元素若为出口，则跳出 while()
            if(gTop.getX() == row-1 && gTop.getY() == col-1){
                break;
            }
            //右边
            if(gTop.getPathState(Constant.RIGHT) == Constant.GOABLE){
                //将右边节点 压栈
                mySqStackUtil.push(mazeNodes[gTop.getX()][gTop.getY()+1]);
                mazeNodes[gTop.getX()][gTop.getY()].setPathState(Constant.RIGHT,Constant.NotGOABLE);
                mazeNodes[gTop.getX()][gTop.getY()+1].setPathState(Constant.LEFT,Constant.NotGOABLE);
                //continue在java中是跳出本次循环，继续执行下一次循环
                continue;
            }
            //左边
            if(gTop.getPathState(Constant.LEFT) == Constant.GOABLE ){
                mySqStackUtil.push(mazeNodes[gTop.getX()][gTop.getY()-1]);
                mazeNodes[gTop.getX()][gTop.getY()].setPathState(Constant.LEFT,Constant.NotGOABLE);
                mazeNodes[gTop.getX()][gTop.getY()-1].setPathState(Constant.RIGHT,Constant.NotGOABLE);
                continue;
            }
            //上边
            if(gTop.getPathState(Constant.UP) == Constant.GOABLE ){
                mySqStackUtil.push(mazeNodes[gTop.getX()-1][gTop.getY()]);
                mazeNodes[gTop.getX()][gTop.getY()].setPathState(Constant.UP,Constant.NotGOABLE);
                mazeNodes[gTop.getX()-1][gTop.getY()].setPathState(Constant.DOWN,Constant.NotGOABLE);
                continue;
            }
            //下边
            if(gTop.getPathState(Constant.DOWN) == Constant.GOABLE ){
                mySqStackUtil.push(mazeNodes[gTop.getX()+1][gTop.getY()]);
                mazeNodes[gTop.getX()][gTop.getY()].setPathState(Constant.DOWN,Constant.NotGOABLE);
                mazeNodes[gTop.getX()+1][gTop.getY()].setPathState(Constant.UP,Constant.NotGOABLE);
                continue;
            }
            //若该节点走到了死胡同，就出栈
            mySqStackUtil.pop();
        }
    }

    /**
     * 打印迷宫
     */
    public void showPath() {

        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                System.out.print(mazeNodes[i][j].getVal()+ " ");
            }
            System.out.println();
        }
    }
    //打印路径
    public void show() {
        if (mySqStackUtil.isEmpty()) {
            System.out.println("此迷宫无路径~");
            return;
        }
        while (!mySqStackUtil.isEmpty()) {
            MazeNode m = mySqStackUtil.getTop();
            m.setVal(8);
            mySqStackUtil.pop();
        }
        System.out.println("迷宫路径为：");

        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                System.out.print(mazeNodes[i][j].getVal() + " ");
            }
            System.out.println();
        }
    }

}

MazeNode 类

package com.tulun.dao;

import com.tulun.constant.Constant;

/**
 * 节点类
 */
public class MazeNode {
    // x坐标（行所在位置）
    private int x;
    // y坐标（列所在位置）
    private int y;
    //结点内的值，是 0 还是 1
    private int val;
    //结点的状态数组，能走还是不能走
    private boolean[] hashTable;
    //变量初始化
    public MazeNode(int x,int y,int val){
        this.x = x;
        this.y = y;
        this.val = val;
        this.hashTable = new boolean[4];
        for (int i = 0;i < hashTable.length;i++){
            hashTable[i] = Constant.NotGOABLE;
        }
    }

    public int getX() { return x; }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }

    /**
     * 需要写一个结点能否走的状态方法
     * 设置状态
     * @param n
     * @param m
     */
    public void setPathState(int n,boolean m){
        hashTable[n] = m;
    }

    public boolean getPathState(int n){
        return hashTable[n];
    }
}

Main 类

package com.tulun.main;


import com.tulun.dao.Maze;

import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        System.out.println("========欢迎来到迷宫世界==========");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入迷宫的行数：");
        int row = scanner.nextInt();
        System.out.println("请输入迷宫的列数：");
        int col = scanner.nextInt();
        Maze maze = new Maze(row,col);
        //开始给二维数组赋值
        int value = 0;
        System.out.println("=========请输入迷宫的路径===========");
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                value = scanner.nextInt();
                maze.setMazeNodes(i,j,value);
            }
        }
        maze.showPath();
        maze.judgePath();
        maze.goMaze();
        maze.show();
    }
}

MySqStackUtil 类

package com.tulun.util;

import com.tulun.dao.MazeNode;

public class MySqStackUtil {
    //top 栈顶标识
    private int top;
    //数组实现栈
    private MazeNode[] elem;
    //栈对象
    MySqStackUtil mySqStackUtil;
    //初始化栈大小为10
    public MySqStackUtil() {
        this(10);
    }
    //初始化栈类型为 MazeNode 类型
    public MySqStackUtil(int size) {
        this.elem = new MazeNode[size];
    }

    /**
     * 判断是否为满
     * @return
     */
    public boolean isFull() {
        if(this.top == this.elem.length) {
            return true;
        }
        return false;
    }

    /**
     * 压栈，压结点类型
     * @param mazeNode
     */
    public void push(MazeNode mazeNode) {
        if(isFull()) {
            return;
        }
        this.elem[top++] = mazeNode;
    }

    /**
     * 判断是否为空
     * @return
     */
    public boolean isEmpty() {
        return this.top == 0;
    }

    /**
     * 出栈
     */
    public void pop() {
        if(isEmpty()) {
            return;
        }
        this.top--;
    }

    /**
     * 返回栈顶元素
     * @return
     */
    public MazeNode getTop(){
        return elem[this.top-1];
    }
}

运行示例 <1> :

运行示例 <2> :