利用栈实现迷宫找路

利用栈实现迷宫找路

代码是练习时写的，写的可能不太好，但是功能都可以实现，主要看思路：

实现思路是：

1.给出起点
2.判断改点是不是终点
3.列出上下左右四个方向的值
4.判断各个方向是否通行（如果通行就递归调用方法本身，并将这个点入栈）
5.如果一条路走不通了就返回，并将当前点出栈
6.这样递归下去最终会找到出口

首先自己定义一个地图类：

package 地图找路;

public class MapData {
	/**
	 * 初始化地图
	 * 1 表示墙
	 * 0 表示可走
	 */
	public static final Integer[][] data = new Integer[][]{
		{0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0},
		{1 , 1 , 0 , 0 , 1 , 1 , 1 , 0 , 1 , 0},
		{0 , 1 , 1 , 1 , 1 , 0 , 1 , 0 , 1 , 0},
		{0 , 0 , 1 , 0 , 0 , 0 , 1 , 1 , 1 , 0},
		{0 , 0 , 1 , 1 , 1 , 1 , 0 , 0 , 0 , 0},
		{0 , 0 , 0 , 0 , 0 , 1 , 1 , 1 , 0 , 0},
		{0 , 1 , 1 , 1 , 1 , 1 , 0 , 1 , 0 , 0},
		{0 , 1 , 0 , 1 , 0 , 1 , 0 , 1 , 1 , 0},
		{0 , 1 , 1 , 1 , 0 , 0 , 0 , 0 , 1 , 0},
		{0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1 , 0},
		} ;
	//起点
	private static Point startPoint = new Point(1, 0) ;
	//终点
	private static Point endPoint = new Point(9, 8) ;
	
	public static Point getStart(){
		return startPoint ;
	}
	
	public static Point getEnd(){
		return endPoint ;
	}
	
	public static int getWidth(){
		return data[0].length ;
	}
	
	public static int getHeight(){
		return data.length ;
	}
	//定义一个保存地图中各节点的类
	static class Point{
		private int x ;
		private int y ;
		
		public Point(int x, int y) {
			this.x = x;
			this.y = y;
		}
		public int getX() {
			return x;
		}
		public int getY() {
			return y;
		}
		
		@Override
		public int hashCode() {
			return x*y;
		}
		
		//重写此方法更改对象盘对相等的条件
		@Override
		public boolean equals(Object obj) {
			if(obj == null){
				return false ;
			}
			if(obj instanceof Point){
				if(((Point)obj).getX() == this.x && ((Point)obj).getY() == this.y){
					return true ;
				}
			}
			return false ;
		}
	}
}

实现一个自己的栈

package 栈和队列;

import java.util.LinkedList;

import 地图找路.StackIterator;

public class Stack<T> implements Iterable<T> {
	
	//定义一个储存数据的容器
	private LinkedList<T> linker = new LinkedList<T>();
	
	//记录栈的大小
	private int size = 0 ;
	
	//入栈
	public void push(T t){
		linker.addFirst(t);
		size++ ;
	}
	
	//出栈
	public T pop(){
		if(size == 0){
			return null ;
		}
		T t = linker.getFirst() ;
		linker.removeFirst() ;
		size-- ;
		return t ;
	}
	
	public int size(){
		return size ;
	}
	//判断栈中是否有当前对象
	public boolean has(T t){
		for(int i=0 ; i<size ; i++){
			if(linker.get(i).equals(t)){
				return true ;
			}
		}
		return false ;
	}
}

写主类

package 地图找路;

import 地图找路.MapData.Point;
import 栈和队列.Stack;

public class Test {
	
	public static Integer[][] data = MapData.data ;
	
	//打印初始地图
	static{
		System.out.println("迷宫地图：\r\n");
		for (Integer[] integers : data) {
			for (Integer i : integers) {
				if(i == 1){
					System.out.print("*  ");
				}else{
					System.out.print(i+"  ");
				}
			}
			System.out.println();
		}
	}
	
	//定义一个栈
	public static Stack<Point> stack = new Stack<Point>() ;
	
	//寻找迷宫出路方法
	public static boolean run(Point op , Point np){
		//判断栈中是否已经包含此节点，如果已经包含就返回false
		if(stack.has(np)){
			//如果此处不将重复节点入栈，结果会不正确
			stack.push(np);
			return false ;
		}
		stack.push(np);
		
		if(np.equals(MapData.getEnd())){
			return true ;
		}
		//定义四个Point对象，表示当前点的上下左右
		Point shang = new Point(np.getX()-1, np.getY());
		Point xia = new Point(np.getX()+1, np.getY());
		Point zuo = new Point(np.getX(), np.getY()-1);
		Point you = new Point(np.getX(), np.getY()+1);
		
		//判断上方是否有路可走
		if(check(shang)){
			if(!shang.equals(op) && data[shang.getX()][shang.getY()] == 1){
				boolean flag = run(np, shang);
				//判断是否已经找到终点 ，如果找到了就一路返回
				if(flag){
					return true ;
				}
				stack.pop();
			}
		}
		
		//判断下方是否有路可走
		if(check(xia)){
			if(!xia.equals(op) && data[xia.getX()][xia.getY()] == 1){
				boolean flag = run(np, xia);
				if(flag){
					return true ;
				}
				stack.pop();
			}
		}
		
		//判断左方是否有路可走
		if(check(zuo)){
			if(!zuo.equals(op) && data[zuo.getX()][zuo.getY()] == 1){
				boolean flag = run(np, zuo);
				if(flag){
					return true ;
				}
				stack.pop();
			}
		}
			
		//判断又方是否有路可走
		if(check(you)){
			if(!you.equals(op) && data[you.getX()][you.getY()] == 1){
				boolean flag = run(np, you);
				if(flag){
					return true ;
				}
				stack.pop();
			}
		}
		
		return false ;
	}
	
	//判断节点是否可用
	public static boolean check(Point p){
		if(p.getX() < MapData.getHeight() && p.getY() < MapData.getWidth() && p.getX() >= 0 && p.getY() >= 0){
			return true ;
		}
		return false ;
	}
	
	//测试
	public static void main(String[] args) {
		Point start = MapData.getStart() ;
		run(null, start) ;
		
		System.out.println("===================================================");
		
		System.out.println("迷宫出路：\r\n");
		for (int i=0 ; i<data.length ; i++) {
			for (int j=0 ; j<data[i].length ; j++) {
				if(stack.has(new Point(i, j))){
					System.out.print("#  ");
					continue ;
				}else if(data[i][j] == 1){
					System.out.print("*  ");
				}else if(data[i][j] == 0){
					System.out.print(data[i][j]+"  ");
				}
			}
			System.out.println();
		}
	}
}

运行结果

	迷宫地图：

0  0  0  0  0  0  0  0  0  0  
*  *  0  0  *  *  *  0  *  0  
0  *  *  *  *  0  *  0  *  0  
0  0  *  0  0  0  *  *  *  0  
0  0  *  *  *  *  0  0  0  0  
0  0  0  0  0  *  *  *  0  0  
0  *  *  *  *  *  0  *  0  0  
0  *  0  *  0  *  0  *  *  0  
0  *  *  *  0  0  0  0  *  0  
0  0  0  0  0  0  0  0  *  0  
===================================================
迷宫出路：

0  0  0  0  0  0  0  0  0  0  
#  #  0  0  *  *  *  0  *  0  
0  #  #  *  *  0  *  0  *  0  
0  0  #  0  0  0  *  *  *  0  
0  0  #  #  #  #  0  0  0  0  
0  0  0  0  0  #  #  #  0  0  
0  *  *  *  *  *  0  #  0  0  
0  *  0  *  0  *  0  #  #  0  
0  *  *  *  0  0  0  0  #  0  
0  0  0  0  0  0  0  0  #  0  

#表示出路，有了这个算法给出任意迷宫都可以算出出路