java自定义栈实现简单迷宫

package stack;



import stack.sq.SqStack;
/**
 * 
 * @author 半步疯子
 * 通过迷宫求解，其中出错的问题就是对引用类型变量的理解不够深刻
 * 传值和传地址不够明确
 * 即使我的引用类型变量被压入栈中，但是我的curpos指向的同样还是对应e中的seat的对象
 * 所以这里不能在原来的nextPos方法上进行修改，修改了之后栈中前一步的position也跟着改变了
 * 如果当前步（curpos）不是可通过的区域，那么就会pop到上一步，但是上一步已经被修改到和
 * 当前位置相同的position了，所以就会造成对角线可通过的情况（因为当前是站在墙“1”上的）
 * 0 1 1 1 1 
 * 1 0 1 1 1（对角线通过，两个0通过；但是迷宫规则，对角线是不能通过的）
 */
public class StackSolveMaze {
	
	/**
	 * 位置坐标
	 * @author Administrator
	 * 
	 */
	private class Position {
		// 非静态内部类中不能放静态的字段 static x static y
		/*
		 * int x;
		 * int y;
		 * 这里的x和y与传统意义上的x和y不同
		 * 为了避免混淆，用row和loc的点定义
		 * 这里的x等价于row（行）
		 * 这里的y等价于col（列）
		 * 行号x和列号y刚好与传统的x、y相反
		 * 
		 */
		int row; 
		int col;
	}

	/**
	 * 栈中的元素类型
	 * @author Administrator
	 * 
	 */
	private class StackElem {
		int ord; // 通道块在路径上的 序号
		Position seat; // 通道块在迷宫中的 坐标位置
		int direction; // 从该通道块走向下一个通道块的 方向
	}

	/**
	 * 存放经过路径的栈
	 */
	SqStack<StackElem> stack = new SqStack<StackElem>();
	private SqStack<StackElem> getStack() {
		return stack;
	}
	
	/**
	 * 存放走过每个点的是否通过的图谱
	 */
	int[][] footPrint = new int[10][10];
	private int[][] getPrintFoot() {
		return footPrint;
	}
	
	/**
	 * 原来的迷宫的图
	 */ 
	static int[][] maze = { 
			{ 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 }, 
			};

	/**
	 * 
	 * @param pos
	 *            位置坐标对象
	 * @return 是否可以通过
	 */
	boolean Pass(Position pos) {
		// if(maze[pos.row][pos.col])
			
		/*
		 * maze中的1表示不可通过 footPrint中的1表示可以走 （1为基础值，如果通过则--，如果最后pop则+=2） 0 1 2
		 * 通过未返回 可通过 通过但是倒回
		 */
		if (maze[pos.row][pos.col] != 1 && footPrint[pos.row][pos.col] == 1)
			return true;
		return false;
	}
	
	/*
	0-------------y col(i)列
	|
	|
	|
	|
	x
	row(j)行
	*/
	Position nextPos(Position curpos, int direction) {
		/*
		 * 这里应该把向南和向向东分开到四个方向最开始的位置
		 * 因为只有向东和向南才是有效前进
		 * 这样可以达到优化
		 * 假如：
		 * 		east = 1;
		 * 		south = 2;
		 * 		west = 3; 
		 * 		north = 4;
		 * 		我当前位置的后一个位置不能通过
		 */
		final int east = 1;
		final int south = 2;
		final int west = 3;
		final int north = 4;
		/*       4        
		 *   3       1
		 *       2
		 */
		//  搞清楚向南和向东的关系
		Position pos = new Position();
		pos.col = curpos.col;
		pos.row = curpos.row;
		if (direction == east)
			pos.col++;
		if (direction == south)
			pos.row++;
		if (direction == west)
			pos.col--;
		if (direction == north)
			pos.row--;	
		return pos;
	}

	boolean mazePath(Position start, Position end) {
		Position curpos = start;
		int curstep = 1;
		SqStack<StackElem> stack = new SqStack<StackElem>();
		// int direction = 1;
		StackElem e;
		for (int i = 0; i < 10; i++)
			for (int j = 0; j < 10; j++)
				footPrint[i][j] = 1;
		do {
			// 当前的位置可以通过
			// 没有走过的位置
			if (Pass(curpos)) {
				footPrint[curpos.row][curpos.col] = 0; // 留下足迹
				e = new StackElem();
				e.ord = curstep;
				e.seat = curpos;
				e.direction = 1;
				System.out.println("第" + e.ord + "步：" + e.seat.row + "行， " + e.seat.col+"列");
				stack.push(e); // 将该点压入栈中
				if (curpos.row == end.row && curpos.col == end.col) {
					this.stack = stack;
					return true; // 若该点为终点，退出
				}

				curpos = nextPos(curpos, 1);
				/*
				 * 默认的寻找方向是向东的
				 */
				curstep++; // 探索下一步
			}else {
				if (!stack.empty()) {  
					e = stack.pop();
					// 若没有这个点，进行回溯
					while (4 == e.direction && !stack.empty()) {
						footPrint[e.seat.row][e.seat.col] = 2;
						// 留下不可通过的标记
						e = stack.pop(); // 退回一步
					}
					// 变换方向
					if (e.direction < 4) {
						e.direction++;
						stack.push(e);
						curpos = nextPos(e.seat, e.direction);
						// 更新下一个点的信息
					}
				}
			}
		} while (!stack.empty());
		return false;
	}
	
	
	public static void main(String[] args) {
		StackSolveMaze ma = new StackSolveMaze();

		StackSolveMaze.Position start = ma.new Position();
		StackSolveMaze.Position end = ma.new Position();
		start.row = 1;
		start.col = 1;
		end.row = 8;
		end.col = 8;
		if (ma.mazePath(start, end)) {
			System.out.println("迷宫可以通过");
		} else {
			System.out.println("迷宫不可通过");
		}
		System.out.println("查看路径的情况：(0表示走过，2表示走过但是不可取)：");
		int[][] foot = ma.getPrintFoot();
		for (int i = 0; i < 10; i++) {
			for (int j = 0; j < 10; j++) {
				System.out.print(foot[i][j] + " ");
			}
			System.out.println();
		}

		System.out.println("迷宫图为：");
		for (int row = 0; row < 10; row++) {
			for (int loc = 0; loc < 10; loc++) {
				System.out.print(maze[row][loc] + " ");
			}
			System.out.println();
		}
		
		
		SqStack<StackElem> stack = ma.getStack();
		while (!stack.empty()) {
			StackElem e = (StackElem)stack.pop();
			System.out.println("第" + e.ord + "步：" + e.seat.row + "行， " + e.seat.col+"列");
		}

	}
}

package stack.sq;

import java.util.Arrays;

/**
 * 基于数组实现的顺序栈
 * 
 * top 永远指向栈顶元素之上的位置
 * top初始值为0    FILO
 * 
 * @author 半步疯子
 * @param <E>
 */
public class SqStack<E> {
    private Object[] data = null;
    private int stackSize = 0; // 栈容量
    private int addSize = 10; // 每次增加的基数  
    private int top = 0; // 栈顶指针（初始化为0，避免对后面造成影响）
    
    
    //--------------------------
    /**
     *	初始化栈操作
     *
     *	complete
     */
    public SqStack(){
        this(10); // 默认栈大小为10
    }
    public SqStack(int initialSize) throws RuntimeException{
        if(initialSize > 0){
            this.stackSize = initialSize;
            data = new Object[initialSize];
            top = 0;
        }else{ 
            throw new RuntimeException("初始化大小不合理：" + initialSize);
        }
    }
    //--------------------------
    /**
     * 获取SqStack的元素个数
     * @return 返回表长
     */
    public int stackLength() {
    	return top;
    }
    
    /**
     * 返回分配的存储长度
     * @return 返回表长
     */
    public int getCapacity() {
    	return stackSize;
    }
    /**
     * 当为空的时候，top为0
     * @return 空时为true  不空的时候为false
     * 
     * complete
     */
    public boolean empty(){
    	return top == 0;
        // return top == 0 ? true : false;
    }
    
    /**
     * 进栈的操作
     * @param e
     * 
     * complete
     */
    public void push(E e){
        if(top == stackSize)   myReallocated();  
            // throw new RuntimeException("栈已满，无法将元素入栈！");
    	 data[top++]=e; 
      
    }
    
    /**
     * 查看栈顶元素但不移除 
     * @return
     * 
     * complete
     */
    @SuppressWarnings("unchecked")
	public E peek() throws RuntimeException{
        if(0 == top){
            throw new RuntimeException("栈为空！");
        }else{
            return (E)data[top-1];
        }
    }
    
    /**
     * 弹出栈顶元素
     * @return
     * 
     * complete
     */
    @SuppressWarnings("unchecked")
	public E pop() throws RuntimeException{
        if(0 == top){
            throw new RuntimeException("栈为空！");
        }else{
        	E value = (E)data[top-1];
        	data[--top] = null;
            return value;
        }
    }
    
    /**
     * complete
     */
    private void myReallocated(){
    	/*
		Object[] temp = new Object[stackSize+addSize];
		stackSize = stackSize+addSize;
		System.arraycopy(data, 0, temp, 0, data.length);
		data = temp;
		*/
		if(top == stackSize){
			stackSize += addSize; //将栈容量加10  或增加到10
            data = Arrays.copyOf(data, stackSize);  //将原数组进行拷贝
        }
		
	}
    
    /**
     * complete
     */
    @SuppressWarnings("unchecked")
	public void stackPrint() {
    	for(int i=0; i<top; i++) {
    		System.out.println((E)data);
    	}
    }
 
}