课程设计-走迷宫

《数据结构程序设计》课程设计报告

（走迷宫）

学院：

班级：

学号：

姓名：

指导教师：

完成日期：

目录

1.设计任务 (3)

2.程序的总体设计 (3)

3.程序的实现 (8)

4.主函数 (9)

5.测试 (10)

6.心得体会 (12)

7.附件 (13)

1.设计任务

程序开始运行时显示一个迷宫地图，迷宫中央有一只老鼠，迷宫的右下方有一个粮仓。游戏的任务是使老鼠走到粮仓处。

要求：

1)迷宫的墙足够结实，老鼠不能穿墙而过；

2）正确检测结果，若老鼠在能走到粮仓处，提示成功，否则提示失败；

3)老鼠形象可辨认，可用键盘操纵老鼠上下左右移动；

2.程序的总体设计

首先，确定迷宫的存储结构，说明位置在迷宫中的行坐标和列坐标。

typedef int Status;

typedef struct

{

int r,c; /*迷宫中位置的坐标*/

}PosType;

typedef struct

{

int m,n;

char arr[RANGE][RANGE]; /*用二维数组表示迷宫*/

}MazeType;

第二，确定放入栈中的元素的存储结构，表明通道块在路径上的“序号”，通道块的坐标位置以及下一步要走的方向。

typedef int directiveType;

typedef struct

{

int step;

PosType seat; /*当前位置在迷宫中的坐标*/

directiveType di; /*从当前位置走到下一位置的方向*/

}ElemType;

第三，确定栈的存储结构。

typedef struct NodeType

{

ElemType data;

struct NodeType *next;

}NodeType,*LinkType;

typedef struct

{

LinkType top; /*链栈的顶点定义*/

int size;

}Stack;

void InitStack(Stack &S) /*构建一个空栈*/

{

S.top=NULL;

S.size=0;

}

Status MakeNode(LinkType &p,ElemType e)

{

p=(NodeType *)malloc(sizeof(NodeType));

if(!p)return FALSE; /*存储分配失败*/

p->data=e;

p->next=NULL;

return TRUE;

}

定义在什么情况下要入栈

Status Push(Stack &S,ElemType e)

{

LinkType p;

if(MakeNode(p,e))

{

p->next=S.top;

S.top=p;

S.size++;

return TRUE;

}

return FALSE;

}

判断栈是否为空

Status StackEmpty(Stack S) /*若栈为空栈，则返回TRUE,否则返回FALSE*/

{

if(S.top==NULL)

return TRUE;

return FALSE;

}

定义在什么情况下要出栈

Status Pop(Stack &S,ElemType &e)

{

LinkType p;

if(StackEmpty(S))

return FALSE;

else

{

p=S.top;

S.top=S.top->next;

e=p->data;

S.size--;

free(p);

return TRUE;

}

}

定义什么情况下迷宫可以走

Status pass(MazeType maze,PosType curpos) {

int m,n;

m=curpos.r;

n=curpos.c;

if(maze.arr[m][n]==' ')

return TRUE;

return FALSE;

}

定义什么情况下已经走出了迷宫

Status Same(PosType curpos,PosType end)

{

if(curpos.r==end.r && curpos.c==end.c)

return TRUE;

return FALSE;

}

定义走通的位置要用*标记

void FootPrint(MazeType &maze,PosType curpos) {

int m,n;

m=curpos.r;

n=curpos.c;

maze.arr[m][n]='*';

}

定义在探索过程中老鼠走的方向关系

PosType NextPos(PosType curpos,int di)

{

switch(di)

{

case 1:

curpos.c++;

break;

case 2:

curpos.r++;

break;

case 3:

curpos.c--;

break;

case 4:

curpos.r--;

break;

}

return curpos;

}

定义走过但没有走通位置要用@标记

void MarkPrint(MazeType &maze,PosType p)

{

maze.arr[p.r][p.c]='@';

}

void PrintMaze(MazeType ma)

{

int i,j;

printf("\n");

for(i=0;i

{

printf("\t");

for(j=0;j

{

printf("%c ",ma.arr[i][j]);

}

printf("\n");

}

printf("\n");

}

将数组转化为迷宫

void InitMaze(MazeType &maze,int a[M][N],int row,int col) {

int i,j;

maze.m=row;

maze.n=col;

for(i=0;i

for(j=0;j

{

if(a[i][j]==0)

maze.arr[i][j]=' ';

else

maze.arr[i][j]='#';

}

}

探索迷宫

Status MazePath(MazeType &maze,PosType start,PosType end) {

Stack s;

int curstep=1; //探索第一步

Status found=FALSE;

ElemType e;

PosType curpos=start; //设定当前位置为入口

InitStack(s);

do{

if(pass(maze,curpos)) //当前位置可以通过，即是未曾走过的通道块

{

FootPrint(maze,curpos); //留下足迹

{

e.step=curstep;

e.seat=curpos;

e.di=1;

}

Push(s,e); //加入路径

if(Same(curpos,end))// 到达终点

{

found=TRUE;

}

else

{

curpos=NextPos(curpos,1); //下一位置是当前位置的北邻

curstep++; //探索下一步

}

}

else //当前位置不能通过

if(!StackEmpty(s))

{

Pop(s,e);

while((e.di==4) && !StackEmpty(s))

{

MarkPrint(maze,e.seat); //留下不能通过的标记，并退回一步

Pop(s,e);

curstep--;

}

if(e.di<4)

{

e.di++;

Push(s,e); //探索下一方向

curpos=NextPos(e.seat,e.di); //设定当前位置是该新方向上的相邻块

}

}

}while(!StackEmpty(s) && !found);

return found;

}

void Print(int maze[][N])

{

int i,j;

printf("表示迷宫的数组\n");

for(i=0;i

{

printf("\t");

for(j=0;j

{

printf("%d ",maze[i][j]);

}

printf("\n");

}

printf("\n");

}

3.程序的实现

标记入口位置（说明此位置已试探），把入口压入栈中

栈非空

栈非空

取栈顶元素

初始试探方向

存在试探方向

确定试探位置的坐标

试探位置是否为迷宫出口

打印路径上每

个位置

是否为通道

标记该位置

换个方向试探返回该位置及方向进栈

前进到下一位置

C++ 方向向东

r++ 方向向南

C-- 方向向西

r-- 方向向北

r--

c++

c-- 位置

（c,r）

r++

4.主函数设计

void main()

{

int maze[M][N]={ 输出迷宫数组

1,1,1,1,1,1,1,1,1,1,1,

1,0,1,0,0,1,1,1,0,0,1,

1,0,0,0,0,0,1,0,0,1,1,

1,0,1,1,1,0,0,0,1,1,1,

1,0,0,0,1,0,1,1,0,1,1,

1,1,0,0,1,0,1,1,0,0,1,

1,1,1,0,0,0,0,0,0,0,1,

1,1,1,1,1,1,1,1,1,1,1};

MazeType L;

PosType start,end;

Print(maze);

InitMaze(L,maze,M,N);

start.r=2; 定义迷宫入口和出口 start.c=4;

end.r=6;

end.c=9;

printf("由数组转化出的迷宫");

PrintMaze(L);

if(MazePath(L,start,end))

printf("迷宫的路径，用*表示");

else

printf("此迷宫没有通路！");

PrintMaze(L);

}

5.测试

第一次测试

start.r=2; start.c=4; end.r=6;

end.c=9;

第二个测试

start.r=1; start.c=1; end.r=6;

end.c=9

6.心得体会

数据结构是在整个计算机科学与技术领域上广泛被使用的术语。它用来反映一个数据的内部构成，即一个数据由那些成分数据构成，以什么方式构成，呈什么结构。数据结构有逻辑上的数据结构和物理上的数据结构之分。逻辑上的数据结构反映成分数据之间的逻辑关系，而物理上的数据结构反映成分数据在计算机内部的存储安排。数据结构是数据存在的形式。数据结构是信息的一种组织方式，其目的是为了提高算法的效率，它通常与一组算法的集合相对应，通过这组算法集合可以对数据结构中的数据进行某种操作。数据结构课程的主要目的是介绍一些常用的数据结构，阐明数据结构内在的逻辑关系，讨论它们在计算机中

的存储表示，并结合各种数据结构，讨论对它们实行的各种运算的实现算法。

通过这次数据结构课程设计，让我学到了好多东西。在实际操作过程中犯了一些错误却让我有了意外的收获，所学数据结构理论知识得到了巩固。通过实际操作，学会数据结构程序编程的基本步骤、基本方法，开发了自己的逻辑思维能力，培养了分析问题、解决问题的能力。现在终于挨到了写收获与体会的时候了，的确令人兴奋，看看自己的劳动成果，好开心。

一个星期前的现在，当听到老师布置给我们的题目时，我们都蒙了，这么难的题目我们怎么会啊，但我们只能尽我们自己最大的努力把程序给写出来，虽然知道这一路肯定是异常的艰苦，但豁出去了。

上网查资料、去图书馆查，查相关的函数，经过两三天的努力，我把框架弄出来了，可是还有计算难题摆在我的面前，真的是个难题，自从把框架弄好了以后就没有进展了，眼看一个星期快过去了，我那个急啊，可是急也没有用。我坚持，终于工夫不负有心人，我参照类似程序，改改和添添，终于大功告成，我们欢呼我们雀跃，终于相信我们自己是足够的伟大。

7.附件

#include

#include

#include

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

#define OVERFLOW -2

#define RANGE 20

#define M 8

#define N 11

typedef int Status;

typedef struct

{

int r,c;

}PosType;

typedef struct

{

int m,n;

char arr[RANGE][RANGE];

}MazeType;

typedef int directiveType;

typedef struct

{

int step;

PosType seat;

directiveType di;

}ElemType;

typedef struct NodeType

{

ElemType data;

struct NodeType *next;

}NodeType,*LinkType;

typedef struct

{

LinkType top;

int size;

}Stack;

void InitStack(Stack &S)

{

S.top=NULL;

S.size=0;

}

Status MakeNode(LinkType &p,ElemType e) {

p=(NodeType *)malloc(sizeof(NodeType));

if(!p)return FALSE;

p->data=e;

p->next=NULL;

return TRUE;

}

Status Push(Stack &S,ElemType e)

{

LinkType p;

if(MakeNode(p,e))

{

p->next=S.top;

S.top=p;

S.size++;

return TRUE;

}

return FALSE;

}

Status StackEmpty(Stack S)

{

if(S.top==NULL)

return TRUE;

return FALSE;

}

Status Pop(Stack &S,ElemType &e)

{

LinkType p;

if(StackEmpty(S))

return FALSE;

else

{

p=S.top;

S.top=S.top->next;

e=p->data;

S.size--;

free(p);

return TRUE;

}

}

Status pass(MazeType maze,PosType curpos) {

int m,n;

m=curpos.r;

n=curpos.c;

if(maze.arr[m][n]==' ')

return TRUE;

return FALSE;

}

Status Same(PosType curpos,PosType end) {

if(curpos.r==end.r && curpos.c==end.c)

return TRUE;

return FALSE;

}

void FootPrint(MazeType &maze,PosType curpos) {

int m,n;

m=curpos.r;

n=curpos.c;

maze.arr[m][n]='*';

}

PosType NextPos(PosType curpos,int di)

{

switch(di)

{

case 1:

curpos.c++;

break;

case 2:

curpos.r++;

break;

case 3:

curpos.c--;

break;

case 4:

curpos.r--;

break;

}

return curpos;

}

void MarkPrint(MazeType &maze,PosType p)

{

maze.arr[p.r][p.c]='@';

}

void PrintMaze(MazeType ma)

{

int i,j;

printf("\n");

for(i=0;i

{

printf("\t");

for(j=0;j

{

printf("%c ",ma.arr[i][j]);

}

printf("\n");

}

printf("\n");

}

void InitMaze(MazeType &maze,int a[][N],int row,int col)

{

int i,j;

maze.m=row;

maze.n=col;

for(i=0;i

for(j=0;j

{

if(a[i][j]==0)

maze.arr[i][j]=' ';

else

maze.arr[i][j]='#';

}

}

Status MazePath(MazeType &maze,PosType start,PosType end) {

Stack s;

int curstep=1;

Status found=FALSE;

ElemType e;

PosType curpos=start;

InitStack(s);

do{

if(pass(maze,curpos))

{

FootPrint(maze,curpos);

{

e.step=curstep;

e.seat=curpos;

e.di=1;

}

Push(s,e);

if(Same(curpos,end))

{

found=TRUE;

}

else

{

curpos=NextPos(curpos,1);

curstep++;

}

}

else

if(!StackEmpty(s))

{

Pop(s,e);

while((e.di==4) && !StackEmpty(s)) {

MarkPrint(maze,e.seat);

Pop(s,e);

curstep--;

}

if(e.di<4)

{

e.di++;

Push(s,e);

curpos=NextPos(e.seat,e.di); }

}

}while(!StackEmpty(s) && !found); return found;

}

void Print(int maze[][N])

{

int i,j;

printf("表示迷宫的数组\n");

for(i=0;i

{

printf("\t");

for(j=0;j

{

printf("%d ",maze[i][j]);

}

printf("\n");

}

printf("\n");

}

void main()

{

int maze[M][N]={ 1,1,1,1,1,1,1,1,1,1,1,

1,0,1,0,0,1,1,1,0,0,1,

1,0,0,0,0,0,1,0,0,1,1,

1,0,1,1,1,0,0,0,1,1,1,

1,0,0,0,1,0,1,1,0,1,1,

1,1,0,0,1,0,1,1,0,0,1,

1,1,1,0,0,0,0,0,0,0,1,

1,1,1,1,1,1,1,1,1,1,1};

MazeType L;

PosType start,end;

Print(maze);

InitMaze(L,maze,M,N);

start.r=2;

start.c=4;

end.r=6;

end.c=9;

printf("由数组转化出的迷宫");

PrintMaze(L);

if(MazePath(L,start,end))

printf("迷宫的路径，用*表示"); else

printf("此迷宫没有通路！");

PrintMaze(L);

}