用c++写一个迷宫程序
使用命名空间std
T //类定义了描述迷宫中当前位置的结构类型。
{
公共:
int x；//x表示当前位置的行坐标。
int y；//y表示当前位置的列坐标。
int dir//0:无效，1:东，2:南，3:西，4:北。
};
类链接节点//链接列表节点
{
友元类栈；
公共:
测试数据；
LinkNode * next
};
类堆栈
{
私人:
LinkNode * top//指向第一个节点的堆栈顶部指针
公共:
stack()；//构造函数，空堆栈
~ Stack()；//析构函数
空推(T e)；//将元素数据推送到堆栈上。
t Pop()；//将堆栈的顶部元素移出堆栈
t get pop()；//取出堆栈的顶部元素
void Clear()；//清空堆栈
布尔空()；//判断堆栈是否为空，为空则返回1，否则返回0。
};
Stack::Stack() //构造函数，空栈。
{
top = NULL
}
堆栈::~Stack() //析构函数
{
}
Void Stack::Push(T e) //将元素X推送到堆栈上。
{
link node * P；
p =新LinkNode
p->；数据= e；
p->；next = top
top = P；
}
T Stack::Pop() //使栈顶元素退出栈。
{
测试温度；
link node * P；
P = top
top = top-& gt；接下来；
temp = P-& gt；数据；
删除P；
返回温度；
}
T Stack::GetPop() //取出栈顶元素。
{
返回顶部-& gt；数据；
}
Void Stack::Clear() //清空堆栈。
{
top = NULL
}
Bool Stack::empty() //判断堆栈是否为空，为空则返回1，否则返回0。
{
if(top==NULL)返回1；
否则返回0；
}
int move[4][2]={{0，1}，{1，0}，{0，-1}，{-1，0 } }；//定义当前位置要移动的四个方向。
bool Mazepath(int **maze，int m，int n)；
//在迷宫中找到从(0，0)到(m，n)的路径。
//如果达到，则返回true，否则返回false。
void PrintPath(堆栈p)；//输出迷宫的路径
void Restore(int **maze，int m，int n)；//还原迷宫
int * * get maze(int & amp；m，int & ampn)；//获得迷宫
//返回访问迷宫的二维指针。
int main()
{
int m=0，n = 0；//定义迷宫的长度和宽度。
int * *迷宫；//定义一个二维指针访问迷宫
maze=GetMaze(m，n)；//调用get maze(int &；m，int & ampn)函数，获取迷宫。
If(Mazepath(maze，m，n)) //调用Mazepath(int **maze，int m，int n)函数获取路径。
cout & lt& lt“迷宫路径探索成功了！\ n "；
else cout & lt& lt“这条路不存在！\ n "；
返回0；
}
int * * get maze(int & amp；m，int & ampN)//返回一个二维指针来访问迷宫。
{
int * *迷宫；//定义一个二维指针访问迷宫
int i=0，j = 0；
cout & lt& lt"请输入迷宫的长度和宽度:"；
int a，b；CIN & gt；& gta & gt& gtb；//输入迷宫的长度和宽度。
cout & lt& lt”请输入迷宫内容:\ n”；
m = a；
n = b；//m，n分别代表迷宫的行数和列数。
maze = new int *[m+2]；//申请长度等于行数加2的二级指针。
for(I = 0；我& ltm+2；I++) //申请每个二维指针的空间。
{
maze[I]= new int[n+2]；
}
for(I = 1；我& lt= m；I++) //输入迷宫的内容，0表示可以通行，1表示不可以通行。
for(j = 1；j & lt= n；j++)
CIN & gt；& gt迷宫[I][j]；
for(I = 0；我& ltm+2；i++)
迷宫[I][0]=迷宫[I][n+1]= 1；
for(I = 0；我& ltn+2；i++)
迷宫[0][I]=迷宫[m+1][I]= 1；
返回迷宫；//返回存储迷宫的二维指针迷宫。
};
Bool迷宫路径(int * * maze，int m，int n)//在迷宫迷宫中找到从(0，0)到(m，n)的路径。
//如果达到，则返回true，否则返回false。
{
堆栈q，p；//定义栈P和Q，分别存储探索迷宫的过程和存储路径。
T Temp1，Temp2
int x，y，loop
temp 1 . x = 1；
temp 1 . y = 1；
q . Push(temp 1)；//将入口位置放入堆栈
页（page的缩写）push(temp 1)；
迷宫[1][1]=-1；//表示已经到达入口位置。
而(！Q.empty()) //如果栈Q不为空，则反复探索。
{
temp 2 = q . get pop()；//获取堆栈的顶部元素
如果(！(p.GetPop()。x==q.GetPop()。x & amp& ampp.GetPop()。y==q.GetPop()。y))
页（page的缩写）推送(temp 2)；
//如果堆栈上有一个新位置，则将最后浏览的位置存储在堆栈p中。
for(loop = 0；loop & lt4;Loop++) //浏览当前位置的4个相邻位置。
{
x = temp 2 . x+move[loop][0]；//计算新位置x的位置值。
y = temp 2 . y+move[loop][1]；//计算新位置的Y位置值
If(maze[x][y]==0) //判断新位置是否可达。
{
temp 1 . x = x；
temp 1 . y = y；
迷宫[x][y]=-1；//指示已经到达新位置。
q . Push(temp 1)；//新位置被放入堆栈
}
if((x = =(m))& amp；& amp(y = =(n))//成功到达出口。
{
temp 1 . x = m；
temp 1 . y = n；
temp 1 . dir = 0；
页（page的缩写）push(temp 1)；//将最后一个位置放入堆栈
print path(p)；//输出路径
Restore(迷宫，m，n)；//恢复路径
返回1；//指示路径已成功找到。
}
}
if(p.GetPop()。x==q.GetPop()。x & amp& ampp.GetPop()。y==q.GetPop()。y)
//如果堆栈上没有新位置，则返回到上一个位置。
{
页（page的缩写）pop()；
q . Pop()；
}
}
返回0；//表示搜索失败，即迷宫中没有路径。
}
Void PrintPath(堆栈p) //输出路径
{
cout & lt& lt”迷宫的路径是\ n”；
cout & lt& lt“括号内的内容表示为(行坐标、列坐标、数字方向、方向)\ n”；
栈t；//定义一个栈，按照入口到出口的访问路径。
int a，b；
测试数据；
LinkNode * temp
temp = new LinkNode//申请空间
temp->；data = p . Pop()；//获取堆栈P的顶点元素，即第一个位置。
t.推(温度->；数据)；//第一个位置放入堆栈t。
删除temp//释放空间
而(！P.empty()) //如果堆栈P不为空，则重复转移。
{
temp = new LinkNode
temp->；data = p . Pop()；//获取下一个位置
//获取行走方向
a=t.GetPop()。x-temp->；data.x//线坐标方向
b=t.GetPop()。y-temp->；data.y//列坐标方向
if(a==1) temp->data . dir = 1；//向下的方向，用1表示。
else if(b = = 1)temp-& gt；data . dir = 2；//向右的方向，用2表示。
else if(a = =-1)temp-& gt；data . dir = 3；//向上的方向，用3表示。
else if(b = =-1)temp-& gt；data . dir = 4；//向左的方向，用4表示。
t.推(温度->；数据)；//将新位置放到堆栈上
删除temp
}
//输出路径，包括行坐标、列坐标和下一个位置方向。
而(！T.empty()) //堆栈不为空，继续输出。
{
data = t . Pop()；
cout & lt& lt(' & lt& ltdata.x & lt& lt，' & lt& ltdata.y & lt& lt，' & lt& ltdata.dir & lt& lt",";//输出行坐标和列坐标
Switch(data.dir) //输出对应的方向。
{
案例1:cout & lt；& lt" ↓) \ n "；打破；
案例2:cout & lt；& lt"→)\ n "；打破；
案例三:cout & lt& lt“↑)\ n”；打破；
案例4:cout & lt；& lt"←)\ n "；打破；
案例0:cout & lt；& lt”)\ n”；打破；
}
}
}
Void restore (int * * maze，int m，int n)//还原迷宫。
{
int i，j；
for(I = 0；我& ltm+2；I++) //遍历指针
for(j = 0；j & ltn+2；j++)
{
if(maze[I][J]=-1)//还原探索过的位置，即还原-1为0。
迷宫[I][j]= 0；
}
}
样本输出:
测试1:
请输入迷宫的长度和宽度:5 5。
请输入迷宫的内容:
0 1 1 0 0
0 0 1 1 0
1 0 0 1 1
1 0 0 1 0
1 1 0 0 0
迷宫的路径是
括号中的内容分别表示为(行坐标，列坐标，数字方向，方向)。
(1,1,1,↓)
(2,1,2,→)
(2,2,1,↓)
(3,2,1,↓)
(4,2,2,→)
(4,3,1,↓)
(5,3,2,→)
(5,4,2,→)
(5,5,0,)
迷宫路径探索成功！
测试2:
请输入迷宫的长度和宽度:9 8
请输入迷宫的内容:
0 0 1 0 0 0 1 0
0 0 1 0 0 0 1 0
0 0 0 0 1 1 0 1
0 1 1 1 0 0 1 0
0 0 0 1 0 0 0 0
0 1 0 0 0 1 0 1
0 1 1 1 1 0 0 1
1 1 0 0 0 1 0 1
1 1 0 0 0 0 0 0
迷宫的路径是
括号中的内容分别表示为(行坐标，列坐标，数字方向，方向)。
(1,1,1,↓)
(2,1,1,↓)
(3,1,1,↓)
(4,1,1,↓)
(5,1,2,→)
(5,2,2,→)
(5,3,1,↓)
(6,3,2,→)
(6,4,2,→)
(6,5,3,↑)
(5,5,2,→)
(5,6,2,→)
(5,7,1,↓)
(6,7,1,↓)
(7,7,1,↓)
(8,7,1,↓)
(9,7,2,→)
(9,8,0,)
迷宫路径探索成功！