实验2-1 栈与迷宫求解
【实验目的】
1.熟悉C语言的上机环境VC6，掌握C语言程序设计方法与特点。
2.掌握栈的顺序存储结构的定义及C语言实现。
3.掌握栈的顺序存储结构上的各种基本操作。
4.应用栈实现迷宫通路算法。
5.迷宫求解的关键结构定义及C语言实现。
【问题说明】
一个迷宫可用n阶方阵表示，1表示能通过，0 表示不能通过。现假设老鼠从左上角[1,1]进入迷宫，编写算法，寻求一条从右下角[n,n] 出去的路径。下图是一个迷宫的示意图：
迷宫示意图
【算法基本思想】
迷宫求解是栈的一个典型应用。基本算法思想是：
（1）若当前位置“可通”，则纳入“当前路径”，并继续朝着“下一位置”探索，即切换“下一位置”为“当前位置”，如此重复直至到达出口；
（2）若当前位置“不可通过”，则应顺着“来向”退回到“前一通道块”，然后朝着除“来向”之外的其他方向继续探索；
（3）若该通道块的四周4个方块均“不可通过”，则应从“当前路径”上删除该通道块。
注：
（1）下一位置：“当前位置”四周4个方向（东南西北）上相邻的方块。
（2）假设用栈记录当前路径，则栈顶存放的是“当前路径上最后一个通道块”。
（3）纳入路径：当前位置入栈。
（4）从当前路径上删除前一通道块：出栈。
求迷宫中一条从入口到出口的路径的算法，具体请参见p51。
【实验内容】
1. 顺序栈的初始化、元素的入栈、出栈、以及栈的判空。
2. 迷宫关键操作：
a) 迷宫的初始化
b) 判断当前位置可否通过
c) 为能通过的地方留下足迹，为当前走过的有效的步骤数
d) 探索下一位置并返回下一位置的坐标
e) 曾走过但不通的地方也留下足迹，为-1
f) 关键算法：迷宫存在从入口到出口的通道，则求得一条存放在栈中，并返回ture
g) 输出迷宫
3. 测试：
不同入口和出口的迷宫问题求解路径。
【实验重点】
1、 C语言定义顺序栈
2、 会多文件组织方式编写程序
3、 顺序栈的初始化、元素的入栈、出栈、以及栈的判空操作
4、 迷宫的关键算法。
【实验步骤与代码指导】
1. 定义相关结构：
（1）定义位置类型
typedef struct{
int r; //迷宫矩阵的行
int c; //迷宫矩阵的列
}PosType;
（2）定义栈的元素类型
typedef struct{
int ord; //通道块在路径上的“序号”
PosType seat; //通道块在迷宫中的“坐标位置”
int di; //从此通道块走向下一通道块的“方向”,1-4表示东南西北
}SElemType;
（3）定义顺序/栈类型
typedef struct{
SElemType *base; //栈底指针，栈构造前和销毁后，base为NULL
SElemType *top; //栈顶指针
int stacksize; //当前已分配的存储空间，以元素为单位
}SqStack;
（4）定义迷宫类型
typedef int MazeType[MAXLEN][MAXLEN]; //MAXLEN*MAXLEN二维数组
2．建立头文件maze.h如下：
#ifndef _MAZE_H
#define _MAZE_H
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include "common.h"
#define STACK_INIT_SIZE 100 //存储空间初始化分配量
#define STACK_INCREMENT 10 //存储空间分配增量
#define MAXLEN 10
typedef struct{
int r; //迷宫矩阵的行
int c; //迷宫矩阵的列
}PosType;
typedef struct{
int ord; //通道块在路径上的“序号”
PosType seat; //通道块在迷宫中的“坐标位置”
int di; //从此通道块走向下一通道块的“方向”,1-4表示东南西北
}SElemType; //栈的元素类型
typedef struct{
SElemType *base; //栈底指针，栈构造前和销毁后，base为NULL
SElemType *top; //栈顶指针
int stacksize; //当前已分配的存储空间，以元素为单位
}SqStack; //栈类型-顺序存储
typedef int MazeType[MAXLEN][MAXLEN]; //MAXLEN*MAXLEN二维数组 //迷宫类型
Status InitStack(SqStack &S); //初始化栈
Status DestroyStack(SqStack &S); //销毁栈
Status Push(SqStack &S,SElemType e); //向栈顶插入元素
Status Pop(SqStack &S,SElemType &e); //出栈
Status StackEmpty(SqStack S); //栈是否为空
Status InitMaze(MazeType &maze); //初始化迷宫
Status Pass(MazeType &maze,PosType curpos); //判断当前位置可否通过
Status FootPrint(MazeType &maze,PosType curpos,int curstep); //留下足迹，足迹为步骤数
PosType NextPos(PosType curpos,int i); //探索下一位置并返回下一位置的坐标
Status MarkPrint(MazeType &maze,PosType curpos); //曾走过但不通留下标记-1
//迷宫maze存在从入口start到end的通道则求得一条存放在栈中
Status MazePath(MazeType &maze,PosType start,PosType end);
void PrintMaze(MazeType &maze); //输出迷宫
#endif
3. 再建立一个头文件common.h如下：
#ifndef _COMMON_H
#define _COMMON_H
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;
#endif
4. 将实现放在Maze.cpp里，文件内容如下：
#include <time.h>
#include "maze.h"
Status InitStack(SqStack &S){
S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S.base) exit(OVERFLOW);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}
Status DestroyStack(SqStack &S){
if (S.base!=NULL){
free(S.base);
S.stacksize=0;
printf("顺序栈已经销毁\n");
return OK;
}
else return FALSE;
}
Status Push(SqStack &S,SElemType e){
if (S.top-S.base>=S.stacksize ){
S.base=(SElemType *) realloc(S.base,(S.stacksize+STACK_INCREMENT)*sizeof(SElemType));
if(!S.base) exit(OVERFLOW);
S.top=S.base+S.stacksize;
S.stacksize+=STACK_INCREMENT;
}
*S.top++=e;
return OK;
}
Status Pop(SqStack &S,SElemType &e){
if(S.top==S.base) return ERROR;
e=*--S.top;
return OK;
}
Status StackEmpty(SqStack S){
if (S.base==S.top) return TRUE;
else return FALSE;
}
//定义墙值为0，可通过路径为1，不可通过路径为-1
Status InitMaze(MazeType &maze){
int i,j;
for(i=0;i<MAXLEN;i++){ //迷宫行外墙
maze[0][i]=0;
maze[MAXLEN-1][i]=0;
}
for(i=0;i<MAXLEN;i++){ //迷宫列外墙
maze[i][0]=0;
maze[i][MAXLEN-1]=0;
}
srand((unsigned)time(NULL)); //随机种子
for(i=1;i<MAXLEN-1;i++)
for(j=1;j<MAXLEN-1;j++)
maze[i][j]=1; //初始化迷宫
for(i=1;i<MAXLEN-1;i++){
for(j=1;j<MAXLEN-1;j++){
int n=rand()%29; //利用随机函数随机生成n值
if(n<MAXLEN-1) maze[i][j]=0; //随机设置通道块上的不通的路块
}
}
maze[1][1]=1;
maze[MAXLEN-2][MAXLEN-2]=1;
return OK;
}
void PrintMaze(MazeType &maze){
int i,j;
printf("用递增的数字代表迷宫的从入口到出口的一条路径\n");
printf("用0代表墙和不通的地方用\n用-1代表曾走过的通道块但不通\n");
printf("用1代表可以通过的通道块\n");
printf(" ");
for(i=0;i<MAXLEN;i++) //打印列数名
printf("%4d",i);
printf("\n\n");
for(i=0;i<MAXLEN;i++){
printf("%2d",i); //打印行名
for(j=0;j<MAXLEN;j++)
printf("%4d",maze[i][j]); //输出迷宫//当前位置的标记
printf("\n\n");
}
}
Status Pass(MazeType &maze,PosType curpos){
if(maze[curpos.r][curpos.c]==1) //可通
return TRUE;
else
return FALSE;
}
Status FootPrint(MazeType &maze,PosType curpos,int curstep){
maze[curpos.r][curpos.c]=curstep; //记录可通足迹
return OK;
}
PosType NextPos(PosType curpos,int i){
PosType cpos=curpos;
switch(i){ //1.2.3.4分别表示东,南,西,北方向
case 1 : cpos.c+=1; break;
case 2 : cpos.r+=1; break;
case 3 : cpos.c-=1; break;
case 4 : cpos.r-=1; break;
default: exit(ERROR);
}
return cpos;
}
Status MarkPrint(MazeType &maze,PosType curpos){
maze[curpos.r][curpos.c]=-1; //-1表示曾走过但不通
return OK;
}
Status MazePath(MazeType &maze,PosType start,PosType end){
//若迷宫maze中存在从入口start到出口end的通道，则求得一条存放在栈中（从栈底到栈顶），并返回TRUE；否则返回FALSE
SqStack S; InitStack(S); //初始化栈
PosType curpos=start; //设置"当前位置"为"入口位置"
int curstep=1; //探索第一步
SElemType e;
do{
if(Pass(maze,curpos)){ //当前位置可以通过,即未曾走过的通道块
FootPrint(maze,curpos,curstep); //留下足迹
e.ord=curstep; e.seat=curpos; e.di=1;
Push(S,e); //加入路径
if(curpos.r==end.r && curpos.c==end.c) return TRUE; //到达出口
curpos=NextPos(curpos,1); //下一位置是当前位置的东邻
curstep++; //探索下一步
}
else{ //当前位置不通
if(!StackEmpty(S)){
Pop(S,e);
curstep--;
while(e.di==4 && !StackEmpty(S)){
MarkPrint(maze,e.seat); //留下不能通过的标记,并退一步
Pop(S,e);
curstep--;
}//while
if(e.di<4){
e.di++; //换下一个方向探索
Push(S,e);
curstep++;
curpos=NextPos(e.seat,e.di); //设定当前位置是该新方向上的相邻
}
}
}
}while(!StackEmpty(S));
return FALSE;
}
5. 主函数：
#include <stdio.h>
#include "maze.h"
void main(){
MazeType maze;
PosType start,end;
InitMaze(maze); //初始化并创建迷宫
start.r=1; start.c=1; //迷宫入口坐标
end.c=MAXLEN-2;end.r=MAXLEN-2; //迷宫出口坐标
PrintMaze(maze);
if(MazePath(maze,start,end)){
printf("存在从入口到出口的迷宫路径！\n");
PrintMaze(maze); //打印路径**/
}else printf("迷宫路径不存在！\n");
}
【实验总结】
【实验心得】
浙公网安备 33010602011771号