一、问题介绍
有一个迷宫地图，有一些可达的位置，也有一些不可达的位置（障碍、墙壁、边界）。从一个位置到下一个位置只能通过向上（或者向右、或者向下、或者向左）走一步来实现，从起点出发，如何找到一条到达终点的通路。本文将用两种不同的解决思路，四种具体实现来求解迷宫问题。
用二维矩阵来模拟迷宫地图，1代表该位置不可达，0代表该位置可达。每走过一个位置就将地图的对应位置标记，以免重复。找到通路后打印每一步的坐标，最终到达终点位置。
封装了点Dot，以及深度优先遍历用到的Block，广度优先遍历用到的WideBlock。
private int[][] map = { //迷宫地图,1代表墙壁，0代表通路 {1,1,1,1,1,1,1,1,1,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,0,0,1,1,0,0,1}, {1,0,1,1,1,0,0,0,0,1}, {1,0,0,0,1,0,0,0,0,1}, {1,0,1,0,0,0,1,0,0,1}, {1,0,1,1,1,0,1,1,0,1}, {1,1,0,0,0,0,0,0,0,1}, {1,1,1,1,1,1,1,1,1,1} }; private int mapX = map.length - 1; //地图xy边界 private int mapY = map[0].length - 1; private int startX = 1; //起点 private int startY = 1; private int endX = mapX - 1; //终点 private int endY = mapY - 1;
//内部类，封装一个点
public class Dot{
private int x; //行标
private int y; //列标
public Dot(int x , int y) {
this.x = x;
this.y = y;
}
public int getX(){
return x;
}
public int getY(){
return y;
}
}
//内部类，封装走过的每一个点,自带方向
public class Block extends Dot{
private int dir; //方向,1向上，2向右，3向下，4向左
public Block(int x , int y) {
super(x , y);
dir = 1;
}
public int getDir(){
return dir;
}
public void changeDir(){
dir++;
}
}
/*
广度优先遍历用到的数据结构，它需要一个指向父节点的索引
*/
public class WideBlock extends Dot{
private WideBlock parent;
public WideBlock(int x , int y , WideBlock p){
super(x , y);
parent = p;
}
public WideBlock getParent(){
return parent;
}
}
二、回溯法
思路：从每一个位置出发，下一步都有四种选择（上右下左），先选择一个方向，如果该方向能够走下去，那么就往这个方向走，当前位置切换为下一个位置。如果不能走，那么换个方向走，如果所有方向都走不了，那么退出当前位置，到上一步的位置去，当前位置切换为上一步的位置。一致这样执行下去，如果当前位置是终点，那么结束。如果走过了所有的路径都没能到达终点，那么无解。下面看代码
private Stack<Block> stack = new Stack<Block>(); //回溯法存储路径的栈 public void findPath1(){ Block b = new Block(startX,startY); stack.push(b); //起点进栈 while(!stack.empty()){ //栈空代表所有路径已走完，没有找到通路 Block t = stack.peek(); int x = t.getX(); //获取栈顶元素的x int y = t.getY(); //获取栈顶元素的y int dir = t.getDir(); //获取栈顶元素的下一步方向 map[x][y] = 1; //把地图上对应的位置标记为1表示是当前路径上的位置，防止往回走 if(t.getX() == endX && t.getY() == endY) {//已达终点 return ; } switch(dir){ case 1: //向上走一步 if(x - 1 >= 0 && map[x - 1][y] == 0){ //判断向上走一步是否出界&&判断向上走一步的那个位置是否可达 stack.push(new Block(x - 1 , y)); //记录该位置 } t.changeDir(); //改变方向，当前方向已走过 continue; //进入下一轮循环 case 2: if(y + 1 <= mapY && map[x][y+1] == 0){ stack.push(new Block(x , y + 1)); } t.changeDir(); continue; case 3: if(x + 1 <= mapX && map[x+1][y] == 0){ stack.push(new Block(x + 1 , y)); } t.changeDir(); continue; case 4: if(y - 1 >= 0 && map[x][y - 1] == 0){ stack.push(new Block(x , y - 1)); } t.changeDir(); continue; } t = stack.pop(); //dir > 4 当前Block节点已经没有方向可走,出栈 map[t.getX()][t.getY()] = 0; //出栈元素对应的位置已经不再当前路径上，表示可达 } } //打印栈 public void printStack(){ int count = 1;
while(!stack.empty()){
Block b = stack.pop();
System.out.print("(" + b.getX() + "," + b.getY() + ") ");
if(count % 10 == 0)
System.out.println("");
count++;
} }
测试结果：
递归实现：
private Stack<Block> s = new Stack<Block>(); //回溯法全局辅助栈 private Stack<Block> stack = new Stack<Block>(); //回溯法存储路径的栈
public void findPath2(){ if(startX >= 0 && startX <= mapX && startY >= 0 && startY <= mapY && map[startX][startY] == 0){ find(startX , startY); } } private void find(int x , int y){
map[x][y] = 1; if(x == endX && y == endY) { s.push(new Block(x , y)); while(!s.empty()){ stack.push(s.pop()); } //return ; //在此处返回会使后续递归再次寻找路线会经过这里，如果不返回，整个函数执行完毕，所有路径都会被访问到 } s.push(new Block(x , y));if( x - 1 >= 0 && map[x - 1][y] == 0 ){ //可以往上走，那么往上走 find(x - 1 , y); } if(x + 1 <= mapX && map[x + 1][y] == 0){ //可以往下走，那么往下走 find(x + 1 , y); } if(y - 1 >= 0 && map[x][y - 1] ==0){ //往左 find(x , y - 1); } if(y + 1 <= mapY && map[x][y + 1] == 0){ find(x , y + 1); } if(!s.empty()){ s.pop(); } }
测试结果：
三、深度优先遍历
思路：和上面的回溯法思想基本一样，能向某个方向走下去就一直向那个方向走，不能走就切换方向，所有方向都不能走了就回到上一层位置。
private Stack<Dot> stackDeep = new Stack<Dot>(); //深度遍历时用的存储栈 private Stack<Dot> sDeep = new Stack<Dot>(); //深度遍历时用到的辅助栈 public void findPath3() { // 判断起点的合法性 if (startX >= 0 && startX <= mapX && startY >= 0 && startY <= mapY && map[startX][startY] == 0) { deepFirst(startX, startY); } } public void deepFirst(int x, int y) { Dot b = new Dot(x, y); sDeep.push(b); map[x][y] = 1; // 标记已访问 if (x == endX && y == endY) { while (!sDeep.empty()) { stackDeep.push(sDeep.pop()); } //return ; //此处的return和上一个递归的return一样,如果返回 } for (int i = 1; i <= 4; i++) { // 在每个方向上进行尝试 if (i == 1) { // 上 if (x - 1 >= 0 && map[x - 1][y] == 0) { deepFirst(x - 1, y); } } else if (i == 2) { // 右 if (y + 1 <= mapY && map[x][y + 1] == 0) { deepFirst(x, y + 1); } } else if (i == 3) { // 下 if (x + 1 <= mapX && map[x + 1][y] == 0) { deepFirst(x + 1, y); } } else { // 左 if (y - 1 >= 0 && map[x][y - 1] == 0) { deepFirst(x, y - 1); } } } if(!sDeep.empty()) { sDeep.pop(); // 四个方向都已尝试过，并且没成功，退栈 } } //打印深度优先遍历的栈 public void printDeepStack(){ int count = 1; while(!stackDeep.empty()){ Dot b = stackDeep.pop(); System.out.print("(" + b.getX() + "," + b.getY() + ") "); if(count++ % 10 == 0){ System.out.println(""); } } }
测试结果：
栈实现、递归和深度优先遍历，这三者的执行思路是一样的，都可以看做二叉树先根遍历的变体，起点看做根节点，每个选择方向看做一个分叉，四个方向对应四个子节点，如果某个节点四个方向都走不了，那么它就是叶子节点。每走到一个叶子节点就是一条完整的执行路径，只不过不一定到达了终点。按照先根遍历的方式，最终会走完每一条路径，如果在路径中找到了终点，那么记录下这条路径线索。二叉树先根遍历的递归实现对应了上面的递归实现，只不过这里是四叉树，栈实现可以看成先根遍历的非递归算法，而深度优先遍历和先跟遍历本就有异曲同工之妙。
四、广度优先遍历
思路：这种方法和前面三种是不同的思路。先从根节点出发，将当前节点的所有可达子节点依次访问，在依次访问子节点的子节点，一直下去直到所有节点被遍历。
private WideBlock wb; //广度遍历的终点节点 /* 广度优先遍历 */ public void findPath4(){ wideFirst(); } public void wideFirst(){ WideBlock start = new WideBlock(startX , startY , null); Queue<WideBlock> q = new LinkedList<WideBlock>(); map[startX][startY] = 1; q.offer(start); while(q.peek() != null){ WideBlock b = q.poll(); int x = b.getX(); int y = b.getY(); if(x == endX && y == endY){ //判断当前节点是否已达终点 wb = b; return; } if (x - 1 >= 0 && map[x - 1][y] == 0) { //判断当前节点的能否向上走一步，如果能，则将下一步节点加入队列 q.offer(new WideBlock(x - 1 , y , b)); //子节点入队 map[x - 1][y] = 1; //标记已访问 } if (y + 1 <= mapY && map[x][y + 1] == 0) { //判断当前节点能否向右走一步 q.offer(new WideBlock(x , y + 1 , b)); map[x][y + 1] = 1; } if (x + 1 <= mapX && map[x + 1][y] == 0) { q.offer(new WideBlock(x + 1 , y , b)); map[x + 1][y] = 1; } if (y - 1 >= 0 && map[x][y - 1] == 0) { q.offer(new WideBlock(x , y - 1 , b)); map[x][y -1] = 1; } } } //打印广度遍历的路径 public void printWidePath(){ WideBlock b = wb; int count = 1; while(b != null){ System.out.print("(" + b.getX() + "," + b.getY() + ") "); b = b.getParent(); if(count++ % 10 == 0){ System.out.println(""); } } }
测试结果：
广度优先遍历找出的路径和上面三种方式的结果不一样，它找出的是最短路径。这种方式是从根节点出发，一层一层的往外遍历，当发现某一层上有终点节点时，遍历结束，此时找到的也一定是最短路径，它和二叉树的层序遍历有异曲同工之妙。
本文个人编写，水平有限，如有错误，恳请指出，欢迎评论分享