数据结构与算法之走迷宫

1.走迷宫算法思想

走迷宫有很多种实现方式，包括：

(1)递归:

a.创建一个存储通路结点的栈Stack。

b.从矩阵的第一个结点(0,0)开始，将(0,0)结点压入栈中,顺时针从右->下->左->上寻找通路结点(这里我的设计是值为1的就是通路，值为0的就不是通路，这里的通路结点是要在通向目的结点那条道上的结点)，将每个通路结点压入栈中，直到找到的通路结点是目的结点。

c.设置一个判断是否已经访问过的数组boolean visited[][]，如果结点已经访问过，将数组中对应位置的值设置为true。

d.对于通路结点的选择，要判断是否在边界内，以及是否曾经压入栈中，也就是是否曾经访问过。

(2)深度优先搜索遍历

(3)广度优先搜索遍历

2.算法代码实现

/**
* @description 迷宫结点
* @author liuffei
* @date 2017-07
*/
public class MazeNode {

private int row;//结点行数
private int col;//结点列数

public MazeNode(int row,int col){
this.row = row;
this.col = col;
}

public int getRow() {
return row;
}

public void setRow(int row) {
this.row = row;
}

public int getCol() {
return col;
}

public void setCol(int col) {
this.col = col;
}
}

import java.util.Stack;

/**
* @description 寻找迷宫的出路
* @author liuffei
* @date 2017-06-16
*/
public class MazeRoute {

//创建存储路过结点的栈
public Stack<MazeNode> stack = new Stack<MazeNode>();

//maze中的结点为1表示是通路，0表示不是通路
public  Stack findRoute(int[][] maze){
MazeNode beginNode = new MazeNode(0,0);//进入结点
stack.push(beginNode);
//对于一个结点，从它的右-下-左-上顺时针进行遍历。判断当前节点的邻结点是否为通路，如果是的话，就压入栈中，继续寻找下一个通路。
int x = maze.length;//迷宫矩阵的行数
int y = maze[0].length;//迷宫矩阵的列数
int i = 0,j = 0;//i,j表示当前移动的位置
boolean visited[][] = new boolean[x][y];//标志结点是否有访问过
visited[0][0] = true;
while(i < x - 1 || j < y - 1){
MazeNode nextNode = getNext(beginNode,maze,visited);
if(nextNode.getRow() != beginNode.getRow() || nextNode.getCol() != beginNode.getCol()){
stack.push(nextNode);
beginNode = nextNode;
}
i = nextNode.getRow();
j = nextNode.getCol();
}
return stack;
}

//寻找当前结点的下一个通路 current表示当前结点
public  MazeNode getNext(MazeNode current,int[][] maze,boolean visited[][]){
//表示下一个通路结点
MazeNode next = null;
int x = maze.length;//迷宫矩阵的行数
int y = maze[0].length;//迷宫矩阵的列数
//当前结点current的上下左右结点中一定有一个结点是isWalk = true的。如果其他位置的三个结点都不是通路，则回到这个结点。
//current所在位置
int col = current.getCol();
int row= current.getRow();
//栈顶元素
MazeNode top = stack.peek();
//判断当前结点的右结点(row,col+1)是否是通路，
if(col + 1 < y && maze[row][col+1] == 1 && !visited[row][col+1]){
next = new MazeNode(row,col+1);
visited[row][col+1]  = true;
}else{
//如果右节点不是通路,寻找下结点
if(row + 1 < x && maze[row+1][col] == 1 && !visited[row+1][col]){
next = new MazeNode(row+1,col);
visited[row+1][col]  = true;
}else{
//如果下节点不是通路,寻找左结点
if(col - 1 >= 0 && maze[row][col-1] == 1 && !visited[row][col-1]){
next = new MazeNode(row,col-1);
visited[row][col-1]  = true;
}else{
//如果左结点不是通路，寻找上结点
if(row - 1 >= 0 && maze[row-1][col] == 1  && !visited[row-1][col]){
next = new MazeNode(row-1,col);
visited[row-1][col]  = true;
}else{
//如果上结点都不是通路，就回到栈的栈顶位置。
next = top;
}
}
}

}
return next;
}

}

import java.util.Stack;

/**
* 走迷宫算法测试
* @author liuffei
* @date 2017年7月10日
* @description
*/
public class MazeMain {

public static void main(String[] args) {

int maze[][] = {
{1,0,1,0,0,1,0},
{1,0,0,0,1,0,1},
{1,0,1,1,1,0,0},
{1,1,1,0,1,1,1},
{0,1,0,0,1,0,1},
{0,0,0,0,0,0,1}
};

MazeRoute mazeRoute = new MazeRoute();
Stack stack = mazeRoute.findRoute(maze);
while(!stack.isEmpty()){
MazeNode node = (MazeNode) stack.pop();
System.out.println("("+node.getRow()+","+node.getCol()+")");
}
}

}

3.效果展示