走迷宫问题——非递归算法

1.顺序栈头文件

# include<iostream>
using namespace std;
struct items{
	int x,y;
	char* dir;
};
class SeqStack{        //顺序栈类
private:
	int maxSize;          //栈中可容纳的最大元素个数
	int top;            //栈顶指针：栈中的元素个数，值等于栈顶元素的下标
	items* elements;         //指向栈
public:
	SeqStack(int sz=50);  //构造函数：构造一个最大可容纳sz个元素的栈
	~SeqStack(){delete[] elements;}     //析构函数：释放栈的所有存储空间
	void Push(const items& x);     //进栈函数：把元素x压进栈里
	bool Pop(items& x);           //出栈函数：把栈顶元素的值赋给x，并且使栈顶指针退一格；
	bool isEmpety(){return (top==-1)?true:false;} //判断栈空
	bool isFull(){ return (top+1==maxSize)?true:false;} //判断栈满
	friend ostream& operator<<(ostream& ostr,SeqStack& x); //顺序栈输出运算符的重载
};

2.顺序栈源文件

# include<iostream>
# include<assert.h>
# include"SeqStack.h"
using namespace std;
SeqStack::SeqStack(int sz):top(-1),maxSize(sz){     //构造函数:top=-1表示栈空
	elements=new items[maxSize];       
	assert(elements!=NULL);  //assrt机制：如果满足（）里的条件程序才可继续执行
}
void SeqStack::Push(const items& x){     //
	elements[++top]=x;
}
bool SeqStack::Pop(items& x){          //出栈函数
	if(isEmpety()) return false;
	x=elements[top--];
    return true;
}
ostream& operator<<(ostream& ostr,items& s){   //自定义数据类型items输出重载
	cout<<"("<<s.x<<"<"<<s.y<<")"<<" "<<s.dir<<endl;
	return ostr;
}
ostream& operator<<(ostream& ostr,SeqStack& x){  //栈输出运算符的重载
	for(int i=0;i<=x.top;i++)
		ostr<<x.elements[i]<<endl;
	return ostr;
}

3.走迷宫函数和主函数：

# include<iostream>
# include"SeqStack.h"
void Path(int x,int y,items move[8],int Maze[][4],int mark[][4]);
using namespace std;
const int m=2,p=2;
void main(){
	int i,j;
	int Maze[m+2][p+2];  //定义迷宫数组
	int mark[m+2][p+2];  //定义标记数组
	items move[8]={{-1,0,"N"},{-1,1,"NE"},{0,1,"E"},{1,1,"SE"},
	{1,0,"S"},{1,-1,"SW"},{0,-1,"W"},{-1,-1,"NW"}}; //定义移动数组
	for(i=0;i<m+2;i++)
		for(j=0;j<p+2;j++) cin>>Maze[i][j];//迷宫数组赋值：0，1赋值，能走点赋值0，不能通过的赋值1；
	for(i=0;i<m+2;i++)
		for(j=0;j<p+2;j++) mark[i][j]=0;    //标记数组赋值：都赋值0，表示未走
	mark[1][0]=1; //把mark[0][0]赋值1，表示从[0][0]点出发
	Path(3,3,move,Maze,mark);//调用SeekPath函数，寻找能走出迷宫的路径
	system("pause");
}
void Path(int x,int y,items move[8],int Maze[][4],int mark[][4]){
	int i,j,g,h,n=0;
	char* d;
	SeqStack st(m*p);     //创建一个栈：储存走出迷宫的路径
	items tmp;            //把起点和要走的第一个方向压到栈里
	tmp.x=1;
	tmp.y=0;
	tmp.dir="E";
	st.Push(tmp);
	while(st.isEmpety()==false){   
	n=0;
	st.Pop(tmp);  //栈顶元素出栈，得到出发点：此处分两种情况：1是把起点取出来开始行走；2是走不通时退回上一点再按别的路径行走；
	i=tmp.x;
	j=tmp.y;
	while(n<8){ 
		g=i+move[n].x;         //从该点尝试按8个方向行走
		h=j+move[n].y;
		d=move[n].dir;
		if(g==x&&h==y){       //如果行走到终点，输出走过的路径
			cout<<st;
			cout<<x<<" "<<y<<endl;
			return;
		}
		if(mark[g][h]==0&&Maze[g][h]==0){    //如果该点未走过并且走的通
			mark[g][h]=1;             //走到该点
			tmp.x=i;                  //把上一点和要走的方向压入栈里
			tmp.y=j;
			tmp.dir=d;
			st.Push(tmp);
			i=g;j=h;n=0;             //把该点作为起点，然后把n置0：表示从该点继续按不同方向行走
         }
         else n++;   //走不通的话换一个方向走
	}
	}
	cout<<"no path in Maze"<<endl; //如果栈空，表示退到起点，走不通
}