当前位置：文档之家› 迷宫c语言

迷宫c语言

#include <stdio.h> #include <conio.h>

#include <windows.h>

#include <time.h>

#define Height 31 //迷宫的高度，必须为奇数#define Width 25 //迷宫的宽度，必须为奇数

#define Wall 1

#define Road 0

#define Start 2

#define End 3

#define Esc 5

#define Up 1

#define Down 2

#define Left 3

#define Right 4

int map[Height+2][Width+2];

void gotoxy(int x,int y) //移动坐标

{

COORD coord;

coord.X=x;

coord.Y=y;

SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), coord );

}

void hidden()//隐藏光标

{

HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);

CONSOLE_CURSOR_INFO cci;

GetConsoleCursorInfo(hOut,&cci);

cci.bVisible=0;//赋1为显示，赋0为隐藏

SetConsoleCursorInfo(hOut,&cci);

}

void create(int x,int y) //随机生成迷宫

{

int c[4][2]={0,1,1,0,0,-1,-1,0}; //四个方向

int i,j,t;

//将方向打乱

for(i=0;i<4;i++)

{

j=rand()%4;

t=c[i][0];c[i][0]=c[j][0];c[j][0]=t;

t=c[i][1];c[i][1]=c[j][1];c[j][1]=t;

}

map[x][y]=Road;

for(i=0;i<4;i++)

if(map[x+2*c[i][0]][y+2*c[i][1]]==Wall) {

map[x+c[i][0]][y+c[i][1]]=Road; create(x+2*c[i][0],y+2*c[i][1]);

}

int get_key() //接收按键

{

char c;

while(c=getch())

{

if(c==27) return Esc; //Esc

if(c!=-32)continue;

c=getch();

if(c==72) return Up; //上

if(c==80) return Down; //下

if(c==75) return Left; //左

if(c==77) return Right; //右

}

return 0;

}

void paint(int x,int y) //画迷宫

{

gotoxy(2*y-2,x-1);

switch(map[x][y])

{

case Start:

printf("入");break; //画入口

case End:

printf("出");break; //画出口

case Wall:

printf("※");break; //画墙

case Road:

printf(" ");break; //画路

}

void game()

{

int x=2,y=1; //玩家当前位置，刚开始在入口处

int c; //用来接收按键

while(1)

{

gotoxy(2*y-2,x-1);

printf("☆"); //画出玩家当前位置

if(map[x][y]==End) //判断是否到达出口

{

gotoxy(30,24);

printf("到达终点，按任意键结束"); getch();

break;

}

c=get_key();

if(c==Esc)

{

gotoxy(0,24);

break;

}

switch(c)

{

case Up: //向上走

if(map[x-1][y]!=Wall)

{

paint(x,y);

x--;

}

break;

case Down: //向下走if(map[x+1][y]!=Wall) {

paint(x,y);

x++;

}

break;

case Left: //向左走if(map[x][y-1]!=Wall) {

paint(x,y);

y--;

}

break;

case Right: //向右走if(map[x][y+1]!=Wall) {

paint(x,y);

y++;

}

break;

}

int main()

{

int i,j;

srand((unsigned)time(NULL)); //初始化随即种子

hidden(); //隐藏光标

for(i=0;i<=Height+1;i++)

for(j=0;j<=Width+1;j++)

if(i==0||i==Height+1||j==0||j==Width+1) //初始化迷宫

map[i][j]=Road;

else map[i][j]=Wall;

create(2*(rand()%(Height/2)+1),2*(rand()%(Width/2)+1)); //从随机一个点开始生成迷宫，该点行列都为偶数

for(i=0;i<=Height+1;i++) //边界处理

{

map[i][0]=Wall;

map[i][Width+1]=Wall;

}

for(j=0;j<=Width+1;j++) //边界处理{

map[0][j]=Wall;

map[Height+1][j]=Wall;

}

map[2][1]=Start; //给定入口

map[Height-1][Width]=End; //给定出

口

for(i=1;i<=Height;i++)

for(j=1;j<=Width;j++) //画出迷宫paint(i,j);

game(); //开始游戏

getch();

return 0;

}

首先，先挂上代码。然后说部分废话，读代码好处非常之多，提高技术，增加理解力，以及获得不同思路等。读代码甚至对比写代码来说，学习效率有过之而无不及.文章针对初级又在初级之上，没有一定的基础看不懂，有一定的基础就可以跟着这篇帖子，做出你自己的C语言随机迷宫，这里的做出并不是抄代码，而是变为你真正的知识，在没有参考的时候，也可以流畅的写出你的代码.

然后我们开始分析代码..

先看头文件。

#include <stdio.h> //包涵标准输入输出函数

#include <conio.h> //控制台输入输出库，非标准库哦

#include <windows.h> //WINDOWS.H是主要的头文件，它包含了其他Windows头文件，这些头文件的某些也包含了其他头文件。具体包涵了什么。。太多了自行百度

#include <time.h> //包涵时间和日期处理函数

#define Height 21 //迷宫的高度，必须为奇数

#define Width 21 //迷宫的宽度，必须为奇数

#define Wall 1 //即字面意思墙

#define Road 0 //即字面意思路

#define Start 2 //入口

#define End 3 //终点

#define Esc 5 //退出

#define Up 1 //上，下，左，右

#define Down 2

#define Left 3

#define Right 4

这里为什么要用宏，什么情况下使用宏，可能要问为什么不直接用12345来代替。简单的来说就是提供一个方便，并增加一定的效率。还有重要的一点就是增加代码的可读性。尽量避免用01234这样无意义的数字而使用宏定义能良好的提高开发效率，在小程序中可能不算什么，但是在大程序可就不一样了，然而宏定义也并非只能定义简单的1234 。

接下来我们看一共有几个函数

void gotoxy(int x,int y) //既字面含义移动坐标

void create(int x,int y) //字面含义创建迷宫

void hidden() //隐藏光标（注并非鼠标）

int get_key() //得到按键

void paint(int x,int y) //绘制迷宫

void game() //游戏相关操作

先不要管main函数里的代码，我们先逐个分析一下函数

先来看看gotoxy() 接受两个参数，代码如下

void gotoxy(int x,int y) //移动坐标

{

COORD coord;

coord.X=x;

coord.Y=y;

SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), coord );

}

看到这里可能就有很多人蒙了COORD是个什么东西？COORD实际上是一个结构体包括结构体成员SHORT X,SHORT Y;

typedef struct COORD { SHORT X; SHORT Y;} COORD, *PCOORD;暂时先不管他是做什么的，先看看SetConsoleCursorPosition这个API的声明他接受两个参数，作用是定位光标位置，需要配合COORD 使用

BOOL WINAPI SetConsoleCursorPosition( __in HANDLE hConsoleOutput,

//句柄就不介绍了__in COORD dwCursorPosition // COORD原来是SetConsoleCursorP

osition的形参之一);

GetStdHandle 声明如下：

HANDLE WINAPI GetStdHandle( //获得输入、输出/错误的屏幕缓冲区的句柄。__in DWORD nStdHandle );

而其参数nStdHandle的值可以为下面几种类型的一种：STD_INPUT_HANDLE 标准输入的句柄STD_OUTPUT_HANDLE 标准输出的句柄STD_ERROR_HANDLE 标准错误的句柄

这么说出来其实也并非很容易理解，我们用一个小程序来举例

#include <stdio.h>

#include <windows.h>

int main(void)

{

COORD cod;

cod.X=5;

cod.Y=4;

SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ),

cod );

}

编译一下程序，就能理解这两个函数是做什么的了

gotoxy() 就讲到这里

下面讲第二个函数

声明：void create(int x,int y)

void create(int x,int y) //随机生成迷宫

{

int c[4][2]={0,1,1,0,0,-1,-1,0}; //四个方向// 这里的四个方向乃是0,1 1,0 0,-1 -1,0 代表着上下左右

int i,j,t;

//将方向打乱

for(i=0;i<4;i++)

{

j=rand()%4;

t=c[0];c[0]=c[j][0];c[j][0]=t;

t=c[1];c[1]=c[j][1];c[j][1]=t;

}

map[x][y]=Road;

for(i=0;i<4;i++)

if(map[x+2*c[0]][y+2*c[1]]==Wall) //

{

map[x+c[0]][y+c[1]]=Road;

create(x+2*c[0],y+2*c[1]);

}

这个函数中的算法根据源代码作者所说是从网上找的.然后搜了搜.我去略长，略长，转到论坛压力略大略大还分别有不会离散数学的和使用深度优先遍历..两种版本，最主要的是带图了，推荐亲自前去观看吧https://www.doczj.com/doc/6d11080019.html,/view/f22455126edb6f1aff001f13.html ，带上图理解比较容易..所以想要理解算法部分，还是看连接文章吧

然后我们接着说一下int get_key()

函数如下：

int get_key() //接收按键

{

char c;

while(c=getch())

{

if(c==27) return Esc; //Esc

if(c!=-32)continue;

c=getch();

if(c==72) return Up; //上

if(c==80) return Down; //下

if(c==75) return Left; //左

if(c==77) return Right; //右

}

return 0;

}

其实理解这个函数很容易getch() 为无回显获取一个字符，什么叫无回显获取一个字符？写一个小程序来测试一下

#include <conio.h>

#include <stdio.h>

int main()

{

char a;

a=getch();

putch(a);

}

可以发现只会进行输出，而输入时不会显示所输入字符。可能会有人疑惑ESC的ASCII确实是27 可是其他的是什么呀？ASCII中是没有上下左右的值的，这里的值是键盘控制码，不是ASCII！注意了！关于获取某个按键的值可以用以下程序

#include <conio.h>

#include <stdio.h>

int main()

{

int key;

key = getch();

while( key != 27 ) //键入值不为ESC {

printf("%d\n", key);

key = getch();

}

继续看看paint 函数

函数如下

void paint(int x,int y) //画迷宫

{

gotoxy(2*y-2,x-1);

switch(map[x][y])

{

case Start:

printf("入");break; //画入口

printf("出");break; //画出口

case Wall:

printf("※");break; //画墙

case Road:

printf(" ");break; //画路

}

这

个函数实际上比较容易理解，他首先将光标指向入口，然后在main函数中遍历整个map数组，画出地图。也可以不用入出※空格这些来做地图比如改一下

switch(map[x][y])

{

case Start:

printf("1");break; //画入口

case End:

printf("2");break; //画出口

printf("3");break; //画墙

case Road:

printf("4");break; //画路

}

然后就应该能理解了这部分是怎么做到的

接下来我们看最后一个函数void game() //游戏相关操作

void game()

{

int x=2,y=1; //玩家当前位置，刚开始在入口处

int c; //用来接收按键

while(1)

{

gotoxy(2*y-2,x-1); //这里的含义是到达入口处

printf("☆"); //画出玩家当前位置

if(map[x][y]==End) //判断是否到达出口

{

gotoxy(30,24);

printf("到达终点，按任意键结束");

getch();

break;

}

c=get_key();

if(c==Esc)

{

gotoxy(0,24); break;

}

switch(c)

{

case Up: //向上走

if(map[x-1][y]!=Wall) {

paint(x,y);

x--;

}

break;

case Down: //向下走if(map[x+1][y]!=Wall) {

paint(x,y);

x++;

}

break;

case Left: //向左走

if(map[x][y-1]!=Wall)

{

paint(x,y);

y--;

}

break;

case Right: //向右走

if(map[x][y+1]!=Wall)

{

paint(x,y);

y++;

}

break;

}

事实上这个函数也不是很难理解所有函数除了算法部分都不难理解，就看用不用心去读代码了

就像注释那样，gotoxy(2*y-2,x-1); 到达入口处用☆当玩家，然后先

用c语言实现迷宫求解完美源代码

#include #include #include #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define UNDERFLOW -2 typedef int Status; //-----栈开始----- typedef struct{//迷宫中r行c列的位置 int r; int c; }PostType;//坐标位置类型 typedef struct{ int ord;// 当前位置在路径上的序号 PostType seat;// 当前坐标 int di;// 从此通块走向下一通块的“方向” }SElemType;// 栈的元素类型 //定义链式栈的存储结构 struct LNode { SElemType data;//数据域 struct LNode *next;//指针域 }; struct LStack { struct LNode *top;//栈顶指针 }; Status InitStack(LStack &s)//操作结果：构造一个空栈S { struct LNode *p; p=(LNode *)malloc(sizeof(LNode)); if(!p) {printf("分配失败，退出程序"); exit(ERROR); } s.top=p; p->next=NULL; return OK; }

Status StackEmpty(LStack s) //若栈s为空栈，则返回TRUE，否则FALSE { if(s.top->next==NULL) return TRUE; return FALSE; } Status Push(LStack &s,SElemType e)//插入元素e成为新的栈顶元素 { struct LNode *p; p=(LNode *)malloc(sizeof(LNode)); if(!p) exit(OVERFLOW); s.top->data=e; p->next=s.top; s.top=p; return OK; } Status Pop(LStack &s,SElemType &e)//删除s的栈顶元素，并且用e返回其值{ struct LNode *p; if(!(s.top->next)) exit(UNDERFLOW); p=s.top; s.top=p->next; e=s.top->data; free(p); return OK; } Status DestroyStack(LStack &s)//操作结果：栈s被销毁 { struct LNode *p; p=s.top; while(p) { s.top=p->next; free(p); p=s.top; } return OK; } //-----栈结束------ //-----迷宫开始------- #define MAXLEN 10// 迷宫包括外墙最大行列数 typedef struct{ int r;

c语言程序设计迷宫

数据结构课程设计_迷宫问题 /* Name:迷宫 Author:wujilin Description:输入时候一圈都应该是# 入口为（1,1) 如果有出口出口为(M-2,M-2) Date: 16-07-06 20:54 Copyright:wujilin */ #include #include #define M 10 //自己规定为10*10的迷宫 #define OK 1 #define ERROR 0 #define OVERFLOW -1 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 int findway(int); int NextStep(int *, int *, int ); typedef struct { int x, y; //坐标 int dir; //方向 }ElemType; typedef struct StackNode//构造栈 { ElemType *base; ElemType *top; int stacksize; }SqStack; int InitStack(SqStack *S)//初始化栈 { S->base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType)); if(!S->base) { printf("memory allocation failed,goodbye"); exit(1); } S->top=S->base; S->stacksize=STACK_INIT_SIZE; return OK; }

123迷宫(C语言版)

#include #include #include #define stack_init_size 200 #define stack_increment 10 #define OVERFLOW 0 #define OK 1 #define ERROE 0 #define TRUE 1 #define FALSE 0 typedef int Status; typedef struct{ int x; int y; }PosType; typedef struct{ int ord; // 通道块在路径上的“序号” PosType seat; //通道块在迷宫中的“坐标位置” int di; //从此通道块走向下一通道块的“方向” }SElemType; typedef struct{ SElemType *base; SElemType *top; int stacksize; }SqStack; int mg[20][20]; /*随机生成迷宫的函数 /*为了能够让尽量能通过，将能通过的块和不能通过的块数量比大致为2:1*/ void Random(){ int i,j,k; srand(time(NULL)); mg[1][0]=mg[1][1]=mg[18][19]=0; //将入口、出口设置为“0”即可通过 for(j=0;j<20;j++) mg[0][j]=mg[19][j]=1; /*设置迷宫外围“不可走”，保证只有一个出口和入口*/ for(i=2;i<19;i++) mg[i][0]=mg[i-1][19]=1; /*设置迷宫外围“不可走”，保证只有一个出口和入口*/ for(i=1;i<19;i++)

C语言课程设计--迷宫

C语言课程设计报告题目：迷宫问题姓名：班级：学号：组员：指导教师：学院：专业：

课程设计（报告）任务及评语

目录第1章课程设计的目的与要求 (1) 1.1 课程设计目的 (1) 1.2 课程设计的实验环境 (1) 1.3 课程设计的预备知识 (1) 1.4 课程设计要求 (1) 第2章课程设计内容 (2) 2.1程序功能介绍 (2) 2.2程序整体设计说明 (2) 2.2.1设计思路 (2) 2.2.2数据结构设计及用法说明 (3) 2.2.3程序结构（流程图） (4) 2.2.4各模块的功能及程序说明 (6) 2.2.5程序结果 (7) 2.3程序源代码及注释 (7) 第3章课程设计总结 (17) 参考资料 (18)

第1章课程设计的目的与要求 1.1 课程设计目的本课程设计是计算机科学与技术专业重要的实践性环节之一，是在学生学习完《程序设计语言(C)》课程后进行的一次全面的综合练习。本课程设计的目的和任务： 1. 巩固和加深学生对C语言课程的基本知识的理解和掌握 2. 掌握C语言编程和程序调试的基本技能 3. 利用C语言进行基本的软件设计 4. 掌握书写程序设计说明文档的能力 5. 提高运用C语言解决实际问题的能力 1.2 课程设计的实验环境硬件要求能运行Windows 2000/XP操作系统的微机系统。C语言程序设计及相应的开发环境。 1.3 课程设计的预备知识熟悉C语言及C语言开发工具。 1.4 课程设计要求 1. 分析课程设计题目的要求 2. 写出详细设计说明 3. 编写程序代码，调试程序使其能正确运行 4. 设计完成的软件要便于操作和使用 5. 设计完成后提交课程设计报告

C语言迷宫程序

基于栈的C语言迷宫问题与实现一．问题描述多年以来，迷宫问题一直是令人感兴趣的题目。实验心理学家训练老鼠在迷宫中寻找食物。许多神秘主义小说家也曾经把英国乡村花园迷宫作为谋杀现场。于是，老鼠过迷宫问题就此产生，这是一个很有趣的计算机问题，主要利用“栈”是老鼠通过尝试的办法从入口穿过迷宫走到出口。迷宫只有两个门，一个叫做入口，另一个叫做出口。把一只老鼠从一个无顶盖的大盒子的入口处赶进迷宫。迷宫中设置很多隔壁，对前进方向形成了多处障碍，在迷宫的唯一出口处放置了一块奶酪，吸引老鼠在迷宫中寻找通路以到达出口。求解迷宫问题，即找出从入口到出口的路径。一个迷宫可用上图所示方阵[m,n]表示，0表示能通过，1 表示不能通过。现假设耗子从左上角[1,1]进入迷宫，编写算法，寻求一条从右下角[m,n] 出去的路径。下图是一个迷宫的示意图：迷宫示意图二．算法基本思想迷宫问题是栈应用的一个典型例子。求解过程可采用回溯法。回溯法是一种不断试探且及时纠正错误的搜索方法。从入口出发，按某一方向向前探索，若能走通（未走过的），即某处可以到达，则到达新点，否则试探下一方向; 若所有的方向均没有通路，则沿原路返回前一点，换下一个方向再继续试探，直到所有可能的通路都探索到，或找到一条通路，或无路可走又返回到入口点。在求解过程中，为了保证在到达某一点后不能向前继续行走（无路）时，能正确返回前

一点以便继续从下一个方向向前试探，则需要用一个栈保存所能够到达的每一点的下标及从该点前进的方向，栈中保存的就是一条迷宫的通路。为了确保程序能够终止，调整时，必须保证曾被放弃过的填数序列不被再次试验，即要求按某种有序模型生成填数序列。给解的候选者设定一个被检验的顺序，按这个顺序逐一生成候选者并检验。三．主要数据结构 1.方阵栈： #define STACK_INI_SIZE 100 typedef struct { int *top; //指向栈的顶端域 int *base; //指向栈的低端域 int length; //栈的长度 int stacksize; //栈的最大长度 }sqstack; 2．产生迷宫的矩阵二维数组为了使每一个迷宫存在迷宫的边界和两个端口：入口、出口，设置了一个二维数组，在迷宫的周边定义为1，使得迷宫存在边界，并在（1,1），（x-2,y-2）初定义为0，即定义迷宫的出口，大大减小了无解的情况。 for(i=0;i

迷宫游戏C语言代码讲解

/*迷宫游戏by CDQ*/ /* vc++ 6.0 编译成功本程序参照网上一个特殊算法随机生成迷宫该算法优点：效率高，从入口到出口只有唯一路径，入口出口自己设定该算法缺点：宽度高度都必须为奇数，只能生成n*m矩阵迷宫 */ #include #include #include #include #define Height 31 //迷宫的高度，必须为奇数 #define Width 25 //迷宫的宽度，必须为奇数 #define Wall 1 #define Road 0 #define Start 2 #define End 3 #define Esc 5 #define Up 1 #define Down 2 #define Left 3 #define Right 4 int map[Height+2][Width+2]; void gotoxy(int x,int y) //移动坐标 { COORD coord; coord.X=x; coord.Y=y; SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), coord ); } void hidden()//隐藏光标 { HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); CONSOLE_CURSOR_INFO cci; GetConsoleCursorInfo(hOut,&cci); cci.bVisible=0;//赋1为显示，赋0为隐藏 SetConsoleCursorInfo(hOut,&cci); } void create(int x,int y) //随机生成迷宫 { int c[4][2]={0,1,1,0,0,-1,-1,0}; //四个方向 int i,j,t;

求解迷宫问题(c语言,很详细哦)

求迷宫问题就是求出从入口到出口的路径。在求解时,通常用的是“穷举求解”的方法,即从入口出发,顺某一方向向前试探,若能走通,则继续往前走；否则沿原路退回,换一个方向再继续试探,直至所有可能的通路都试探完为止。为了保证在任何位置上都能沿原路退回(称为回溯),需要用一个后进先出的栈来保存从入口到当前位置的路径。首先用如图所示的方块图表示迷宫。对于图中的每个方块,用空白表示通道,用阴影表示墙。所求路径必须是简单路径,即在求得的路径上不能重复出现同一通道块。为了表示迷宫,设置一个数组mg,其中每个元素表示一个方块的状态,为0时表示对应方块是通道,为1时表示对应方块为墙,如图所示的迷宫,对应的迷宫数组mg如下: int mg[M+1][N+1]={ /*M=10,N=10*/ {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} }; 伪代码：

c语言描述如下： void mgpath() /*路径为:(1,1)->(M-2,N-2)*/ { int i,j,di,find,k; top++; /*初始方块进栈*/ Stack[top].i=1; Stack[top].j=1;

求解迷宫问题(c语言,很详细哦)

求迷宫问题就是求出从入口到出口的路径。在求解时, 通常用的是“穷举求解”的方法,即从入口出发,顺某一方向向前试探,若能走通, 则继续往前走；否则沿原路退回,换一个方向再继续试探, 直至所有可能的通路都试探完为止。为了保证在任何位置上都能沿原路退回（称为回溯）, 需要用一个后进先出的栈来保存从入口到当前位置的路径。首先用如图3.3 所示的方块图表示迷宫。对于图中的每个方块,用空白表示通道,用阴影表示墙。所求路径必须是简单路径, 即在求得的路径上不能重复出现同一通道块。为了表示迷宫, 设置一个数组mg,其中每个元素表示一个方块的状态, 为0 时表示对应方块是通道, 为1 时表示对应方块为墙, 如图3.3 所示的迷宫, 对应的迷宫数组mg如下: int mg[M+1][N+1]={ /*M=10,N=10*/ {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} }; 伪代码： c 语言描述如下：

void mgpath() /* 路径为:(1,1)->(M-2,N-2)*/ { int i,j,di,find,k; top++; /* 初始方块进栈*/ Stack[top].i=1; Stack[top].j=1; Stack[top].di=-1; mg[1][1]=-1; while (top>-1) /* 栈不空时循环*/ { i=Stack[top].i; j=Stack[top].j; di=Stack[top].di; if (i==M-2 && j==N-2) /* 找到了出口, 输出路径*/ { printf(" 迷宫路径如下:\n"); for (k=0;k<=top;k++) { printf("\t(%d,%d)",Stack[k].i,Stack[k] .j); if ((k+1)%5==0) printf("\n"); }

c语言实现迷宫问题.

数据结构试验——迷宫问题（一）基本问题 1.问题描述这是心理学中的一个经典问题。心理学家把一只老鼠从一个无顶盖的大盒子的入口处放入，让老鼠自行找到出口出来。迷宫中设置很多障碍阻止老鼠前行，迷宫唯一的出口处放有一块奶酪，吸引老鼠找到出口。简而言之，迷宫问题是解决从布置了许多障碍的通道中寻找出路的问题。本题设置的迷宫如图1所示。入口出口图1 迷宫示意图迷宫四周设为墙；无填充处，为可通处。设每个点有四个可通方向，分别为东、南、西、北(为了清晰，以下称“上下左右”)。左上角为入口。右下角为出口。迷宫有一个入口，一个出口。设计程序求解迷宫的一条通路。 2.数据结构设计以一个m×n的数组mg表示迷宫，每个元素表示一个方块状态，数组元素0和1分别表示迷宫中的通路和障碍。迷宫四周为墙，对应的迷宫数组的边界元素均为1。根据题目中的数据，设置一个数组mg如下 int mg[M+2][N+2]= { {1,1,1,1,1,1,1,1}, {1,0,0,1,0,0,0,1}, {1,1,0,0,0,1,1,1}, {1,0,0,1,0,0,0,1}, {1,0,0,0,0,0,0,1}, {1,1,1,1,1,1,1,1} };在算法中用到的栈采用顺序存储结构，将栈定义为 Struct { int i; //当前方块的行号 int j; //当前方块的列号 int di; //di是下一个相邻的可走的方位号 }st[MaxSize];// 定义栈

int top=-1 //初始化栈 3设计运算算法要寻找一条通过迷宫的路径，就必须进行试探性搜索，只要有路可走就前进一步，无路可进，换一个方向进行尝试；当所有方向均不可走时，则沿原路退回一步（称为回溯），重新选择未走过可走的路，如此继续，直至到达出口或返回入口（没有通路）。在探索前进路径时，需要将搜索的踪迹记录下来，以便走不通时，可沿原路返回到前一个点换一个方向再进行新的探索。后退的尝试路径与前进路径正好相反，因此可以借用一个栈来记录前进路径。方向：每一个可通点有4个可尝试的方向，向不同的方向前进时，目的地的坐标不同。预先把4个方向上的位移存在一个数组中。如把上、右、下、左（即顺时针方向）依次编号为0、1、2、3.其增量数组move[4]如图3所示。 move[4] x y 0 -1 0 1 0 1 2 1 0 3 0 -1 图2数组move[4] 方位示意图如下：通路：通路上的每一个点有3个属性：一个横坐标属性i、一个列坐标属性j和一个方向属性di，表示其下一点的位置。如果约定尝试的顺序为上、右、下、左（即顺时针方向），则每尝试一个方向不通时，di值增1，当d增至4时，表示此位置一定不是通路上的点，从栈中去除。在找到出口时，栈中保存的就是一条迷宫通路。（1）下面介绍求解迷宫（xi,yj）到终点（xe,ye）的路径的函数：先将入口进栈（其初始位置设置为—1），在栈不空时循环——取栈顶方块（不退栈）①若该方块为出口，输出所有的方块即为路径，其代码和相应解释如下：

迷宫c语言

迷宫c语言 #include <stdio.h> #include <conio.h> #include <windows.h> #include <time.h> #define Height 31 //迷宫的高度，必须为奇数#define Width 25 //迷宫的宽度，必须为奇数 #define Wall 1 #define Road 0 #define Start 2 #define End 3 #define Esc 5 #define Up 1 #define Down 2 #define Left 3 #define Right 4 int map[Height+2][Width+2]; void gotoxy(int x,int y) //移动坐标 {

COORD coord; coord.X=x; coord.Y=y; SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), coord ); } void hidden()//隐藏光标 { HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); CONSOLE_CURSOR_INFO cci; GetConsoleCursorInfo(hOut,&cci); cci.bVisible=0;//赋1为显示，赋0为隐藏 SetConsoleCursorInfo(hOut,&cci); } void create(int x,int y) //随机生成迷宫 { int c[4][2]={0,1,1,0,0,-1,-1,0}; //四个方向 int i,j,t; //将方向打乱 for(i=0;i<4;i++) { j=rand()%4;

C语言编写的迷宫小游戏_源代码

C语言编写的迷宫小游戏源代码 #include #include #include #include #include #define N 20/*迷宫的大小，可改变*/ int oldmap[N][N];/*递归用的数组,用全局变量节约时间*/ int yes=0;/*yes是判断是否找到路的标志,1找到，0没找到*/ int way[100][2],wayn=0;/*way数组是显示路线用的,wayn是统计走了几个格子*/ void Init(void);/*图形初始化*/ void Close(void);/*图形关闭*/ void DrawPeople(int *x,int *y,int n);/*画人工探索物图*/ void PeopleFind(int (*x)[N]);/*人工探索*/ void WayCopy(int (*x)[N],int (*y)[N]);/*为了8个方向的递归，把旧迷宫图拷贝给新数组*/ int FindWay(int (*x)[N],int i,int j);/*自动探索函数*/ void MapRand(int (*x)[N]);/*随机生成迷宫函数*/ void PrMap(int (*x)[N]);/*输出迷宫图函数*/ void Result(void);/*输出结果处理*/ void Find(void);/*成功处理*/ void NotFind(void);/*失败处理*/ void main(void)/*主函数*/ { int map[N][N]; /*迷宫数组*/ char ch; clrscr(); printf("\n Please select hand(1) else auto\n");/*选择探索方式*/ scanf("%c",&ch); Init(); /*初始化*/ MapRand(map);/*生成迷宫*/ PrMap(map);/*显示迷宫图*/ if(ch=='1') PeopleFind(map);/*人工探索*/ else FindWay(map,1,1);/*系统自动从下标1,1的地方开始探索*/ Result();/*输出结果*/ Close(); } void Init(void)/*图形初始化*/ {

C语言走迷宫之完美版

C语言走迷宫之完美版 #include<stdio.h> #include<time.h> #include<stdlib.h> int maze[100][100];//定义最大迷宫数组 int m,n;//定义行列 typedef struct pos//定义位置的结构体 { int x;//定义行 int y;//定义列 }pos; typedef struct//定义顺序栈 { pos base[100];//定义顺序栈存储结构 int top;//头指针 }stack; int isEmpty(stack);//定义判断栈是否为空的函数 void push(stack *,int,int);//入栈 void pop(stack *,int *,int *);//出栈 int isEmpty(stack s1)//判断栈是否为空的函数 { if(s1.top==0)//当头指针指向首地址时栈为空并返回1 return 1;//返回1 return 0;//否则返回0 } void push(stack *s1,int x,int y)//入栈 { (s1->base[s1->top]).x=x;//将当前行坐标存入栈 (s1->base[s1->top]).y=y;//y同上 s1->top++;//指针指向下一个位置 } void pop(stack *s1,int *x,int *y)//出栈 { s1->top--;//指针指向前一个位置 *x=(s1->base[s1->top]).x;//将当前行坐标赋给x所指向的元素*y=(s1->base[s1->top]).y;//y同上 } void main()//主函数 { void InitMaze();//初始化迷宫

迷宫(C语言版)

/*注：本程序探索迷宫的优先顺序=> 1-下、2-右、3-上、4-左<=总体趋势：下右，逆时针方向。因为出口就在右边下方*/ #include #include #include #define stack_init_size 200 #define stack_increment 10 #define OVERFLOW 0 #define OK 1 #define ERROE 0 #define TRUE 1 #define FALSE 0 typedef int Status; typedef struct{ int x; int y; }PosType; typedef struct{ int ord; // 通道块在路径上的“序号” PosType seat; //通道块在迷宫中的“坐标位置” int di; //从此通道块走向下一通道块的“方向” }SElemType; typedef struct{ SElemType *base; SElemType *top; int stacksize; }SqStack; int mg[20][20]; /*随机生成迷宫的函数 /*为了能够让尽量能通过，将能通过的块和不能通过的块数量比大致为2:1*/ void Random(){ int i,j,k; srand(time(NULL)); mg[1][0]=mg[1][1]=mg[18][19]=0; //将入口、出口设置为“0”即可通过 for(j=0;j<20;j++) mg[0][j]=mg[19][j]=1; /*设置迷宫外围“不可走”，保证只有一个出口和入口*/ for(i=2;i<19;i++) mg[i][0]=mg[i-1][19]=1; /*设置迷宫外围“不可走”，保证只有一个出

C语言迷宫程序

基于栈的C语言迷宫问题与实现一. 问题描述多年以来，迷宫问题一直是令人感兴趣的题目。实验心理学家训练老鼠在迷宫中寻找食物。许多神秘主义小说家也曾经把英国乡村花园迷宫作为谋杀现场。于是，老鼠过迷宫问题就此产生, 这是一个很有趣的计算机问题，主要利用“栈”是老鼠通过尝试的办法从入口穿过迷宫走到岀口。迷宫只有两个门，一个叫做入口，另一个叫做岀口。把一只老鼠从一个无顶盖的大盒子的入口处赶进迷宫。迷宫中设置很多隔壁，对前进方向形成了多处障碍，在迷宫的唯一岀口处放置了一块奶酪，吸引老鼠在迷宫中寻找通路以到达出口。求解迷宫问题，即找出从入口到出口的路径。一个迷宫可用上图所示方阵［m,n］表示，0表示能通过，1表示不能通过。现假设耗子从左上角［1,1］进入迷宫，编写算法，寻求一条从右下角［m,n］岀去的路径。下图是一个迷宫的示意图：算法基本思想迷宫问题是栈应用的一个典型例子。求解过程可采用回溯法。回溯法是一种不断试探且及时纠正错误的搜索方法。从入口岀发，按某一方向向前探索，若能走通（未走过的），即某处可以到达，则到达新点，否则试探下一方向；若所有的方向均没有通路，则沿原路返回前一点，换下一个方向再继续试探，直到所有可能的通路都探索到，或找到一条通路，或无路可走又返回到入口点。在求解过程中，为了保证在到达某一点后不能向前继续行走（无路）时，能正确返回前一点以便继续从下一个方向向前试探，则需要用一个栈保存所能够到达的每一点的下标及从该点前进的方向，栈中保存的就是一条迷宫的通路。为了确保程序能够终止，调整时，必须保证曾被放弃过的填数序列不被再次试验，即要求按迷宫示意图

C语言课程设计-迷宫游戏

C语言课程设计-迷宫游戏设计报告题目:完整的二维迷宫游戏学院:工商管理学院专业:信息系统与信息管理班级:050507 姓名:孙月指导教师:张首伟设计日期:2004年12月10日题目:完整的二维迷宫游戏一、选题背景: 问题的提出:我们在玩迷宫游戏的时候,常常在过了一关之后就结束了～这里设计的迷宫游戏足够多～难以程度也不尽相同～可以过瘾的玩。模仿的有那么一点意思～还请多多指教: 二、设计思想: ,1,.问题描述用一个m行n列的二维数组来表示迷宫。数组中每个元素的取值为0或1～其中值0表示通路～值1表示阻塞～入口在左上方,1～1,处～出口在右下方,m,n,处～如图所示。要求求出从迷宫入口到出口有无通路～若有通路则指出其中一条通路的路径～即输出找到通路的迷宫数组～其中通路上的“0”用另一数字,例如8,替换～同时打印出所走通路径上每一步的位置坐标及下一步的方向。 ,2,(求解方法说明:

1(为使问题一般化～假设以二维数组maze(1:m,1:n)表示迷宫～并设maze(i,j)表示任一位置。 2(对每个位置maze(i,j)～可移动的八个方向从正东起顺时针方向顺序为:E～SE～S～SW～W～NW～N～NE。再用一个二维数组move表示这八个方向上坐标的增量～如下表所示～move(v,1)表示第v个方向上i的增量, move(v,2)表示第v个方向上j的增量。三、程序流程图四、程序清单: 一、

二、 #include #include #include #include #include #define N 20/*迷宫的大小～可改变*/ int oldmap[N][N];/*递归用的数组,用全局变量节约时间*/ int yes=0;/*yes 是判断是否找到路的标志,1找到～0没找到*/ int way[100][2],wayn=0;/*way数组是显示路线用的,wayn是统计走了几个格子*/ void Init(void);/*图形初始化*/ void Close(void);/*图形关闭*/ void DrawPeople(int *x,int *y,int n);/*画人工探索物图*/ void PeopleFind(int (*x)[N]);/*人工探索*/ void WayCopy(int (*x)[N],int (*y)[N]);/*为了8个方向的递归～把旧迷宫图拷贝给新数组*/ int FindWay(int (*x)[N],int i,int j);/*自动探索函数*/ void MapRand(int (*x)[N]);/*随机生成迷宫函数*/ void PrMap(int (*x)[N]);/*输出迷宫图函数*/ void Result(void);/*输出结果处理*/ void Find(void);/*成功处理*/

基于栈的C语言迷宫问题与实现

数据结构与算法实验报告

基于栈的C语言迷宫问题与实现一．问题描述多年以来，迷宫问题一直是令人感兴趣的题目。实验心理学家训练老鼠在迷宫中寻找食物。许多神秘主义小说家也曾经把英国乡村花园迷宫作为谋杀现场。于是，老鼠过迷宫问题就此产生，这是一个很有趣的计算机问题，主要利用“栈”是老鼠通过尝试的办法从入口穿过迷宫走到出口。迷宫只有两个门，一个叫做入口，另一个叫做出口。把一只老鼠从一个无顶盖的大盒子的入口处赶进迷宫。迷宫中设置很多隔壁，对前进方向形成了多处障碍，在迷宫的唯一出口处放置了一块奶酪，吸引老鼠在迷宫中寻找通路以到达出口。求解迷宫问题，即找出从入口到出口的路径。一个迷宫可用上图所示方阵[m,n]表示，0表示能通过，1 表示不能通过。现假设耗子从左上角[1,1]进入迷宫，编写算法，寻求一条从右下角[m,n] 出去的路径。下图是一个迷宫的示意图：迷宫示意图二．算法基本思想迷宫求解问题是栈的一个典型应用。基本算法思想是：在某个点上，按照一定的顺序（在本程序中顺序为上、右、下、左）对周围的墙、路进行判断（在本程序中分别用1、0）代替，若周围某个位置为0，则移动到该点上，再进行下一次判断；若周围的位置都为1（即没有通路），则一步步原路返回并判断有无其他通路，然后再次进行相同的判断，直到走到终点为止，或者确认没有任何通路后终止程序。要实现上述算法，需要用到栈的思想。栈里面压的是走过的路径，若遇到死路，则将该位置

（在栈的顶层）弹出，再进行下一次判断；若遇到通路，则将该位置压栈并进行下一次判断。如此反复循环，直到程序结束。此时，若迷宫有通路，则栈中存储的是迷宫通路坐标的倒序排列，再把所有坐标顺序打印后，即可得到正确的迷宫通路。三．程序具体部分的说明 1.迷宫的生成根据题目的要求，迷宫的大小是自定义输入的。所以在程序中用malloc申请动态二维数组。数组中的元素为随机生成的0、1。数组周围一圈的元素全部定义为1，以表示边界。 2.栈的C语言实现为了实现栈的功能，即清空、压栈、弹出、返回栈顶元素，在程序中编写了相应的函数。 MakeNULL 清空栈 Push 将横、纵坐标压栈 Topx 返回栈顶存储的横坐标 Topy 返回栈顶存储的纵坐标 Pop 弹出栈顶元素 3.具体的判断算法当位置坐标（程序中为X Y）移到某一位置时，将这个位置的值赋值为1并压栈，以说明该点已经走过。接着依次判断该点的上、右、下、左是否为0，若有一方为0，则移动到该位置上，进行下次判断；若为周围位置全部是1，则将该点压栈后不断弹出，每次弹出时判断栈顶元素（即走过的路）周围有无其他通路。如果有的话，则选择该方向继续走下去；如果栈已经为空仍然没有找到出路，则迷宫没有出口程序结束。当X Y走到出口坐标时，程序判断部分结束。栈里面存储的是每个走过的点的坐标，将这些横纵坐标分别存储在两个数组中，最后将数组中的坐标元素倒序输出，即得到了完整的路径。四．程序源代码及注释 // Maze.cpp : 定义控制台应用程序的入口点。 // #include"stdafx.h" #include #include #include #include #include typedef int Elementtype; struct node

c语言~走迷宫

本程序代码为C语言解决数据结构（严蔚敏）中关于迷宫的问题。程序不仅实现迷宫路径查找，还实现文字描述路径功能可以直接粘贴到vc6.0中运行

【代码如下】 # include # include # define null 0 typedef struct { int (*base)[2]; int (*top)[2];

int listlen; }sqlist; int topelem[2]; //栈顶元素 void creatstack(sqlist *mazepath); //创建一个存储路径的栈 void creatmap(int (*mazemap)[10]); //创建迷宫图纸 void printmap(int (*mazemap)[10]); void footprint(int x,int y,int k,int (*mazemap)[10]); int position(int x,int y); //判断是否到终点 int passroad(int x,int y,int (*mazemap)[10]); void findpath(int (*mazemap)[10],sqlist *mazepath); //在mazemap当中寻找mazepaht void printpath(sqlist *mazepath); void roadinwords(sqlist *mazepath); //文字叙述如何走迷宫 void push(int x,int y,sqlist *mazepath); //栈操作 void pop(sqlist *mazepath); void gettop(sqlist *mazepath); void main()

基于栈的C语言迷宫问题与实现

数据结构与算法实验报告

[m,n] 出去的路径。下图是一个迷宫的示意图：迷宫示意图二．算法基本思想迷宫求解问题是栈的一个典型应用。基本算法思想是：在某个点上，按照一定的顺序（在本程序中顺序为上、右、下、左）对周围的墙、路进行判断（在本程序中分别用1、0）代替，若周围某个位置为0，则移动到该点上，再进行下一次判断；若周围的位置都为1（即没有通路），则一步步原路返回并判断有无其他通路，然后再次进行相同的判断，直到走到终点为止，或者确认没有任何通路后终止程序。

要实现上述算法，需要用到栈的思想。栈里面压的是走过的路径，若遇到死路，则将该位置（在栈的顶层）弹出，再进行下一次判断；若遇到通路，则将该位置压栈并进行下一次判断。如此反复循环，直到程序结束。此时，若迷宫有通路，则栈中存储的是迷宫通路坐标的倒序排列，再把所有坐标顺序打印后，即可得到正确的迷宫通路。三．程序具体部分的说明 1.迷宫的生成根据题目的要求，迷宫的大小是自定义输入的。所以在程序中用malloc申请动态二维数组。数组中的元素为随机生成的0、1。数组周围一圈的元素全部定义为1，以表示边界。 2.栈的C语言实现为了实现栈的功能，即清空、压栈、弹出、返回栈顶元素，在程序中编写了相应的函数。

c语言迷宫问题代码实现

C语言迷宫问题代码如下： #include #include #define LEN sizeof(SEAT) #define MAXSIZE 100 #define LENGTH 30 typedef struct { int x;//横坐标 int y;//纵坐标 int di;//表示方向，0-3分别表示东南西北。 }SEAT; struct StackList { SEA T stack[MAXSIZE]; int top; }*Stack; int EmptyStack(StackList*Stack)//判断是否为空栈 { if(Stack->top==0) return 0; else return 1; } int Move[4][2]={{0,1},{1,0},{0,-1},{-1,0}};//分别表示向东、西、南、北需要加上的坐标 int Mase[LENGTH][LENGTH]={0};//初始化为0 int length,width; void InitMase()//在迷宫的外围添加一层“墙壁”（赋值为1），使得迷宫的任意一点都有四个方向 { int i,j; for(i=0;i

for(i=0;itop=0; return ; } int PushStack(StackList*Stack,SEAT CurSeat)//进栈{ if(Stack->top==MAXSIZE-1) return false; else { Stack->stack[Stack->top].x=CurSeat.x; Stack->stack[Stack->top].y=CurSeat.y; Stack->stack[Stack->top].di=CurSeat.di; Stack->top++; return true; } } int PopStack(StackList*Stack)//出栈 { if(Stack->top==0) return false; else { Stack->top--; return true; } } int Pass(SEAT p)//判断当前是否可行 { if(Mase[p.x][p.y]==0) { return true; }

文档之家

迷宫c语言

用c语言实现迷宫求解完美源代码

c语言程序设计 迷宫

123迷宫(C语言版)

C语言课程设计--迷宫

C语言迷宫程序

迷宫游戏C语言代码讲解

求解迷宫问题(c语言,很详细哦)

求解迷宫问题(c语言,很详细哦)

c语言实现 迷宫问题.

迷宫c语言

C语言编写的迷宫小游戏_源代码

C语言走迷宫之完美版

迷宫(C语言版)

C语言迷宫程序

C语言课程设计-迷宫游戏

基于栈的C语言迷宫问题与实现

c语言~走迷宫

基于栈的C语言迷宫问题与实现

c语言迷宫问题代码实现

c语言程序设计迷宫

c语言实现迷宫问题.