C语言迷宫程序
用C语言解决迷宫问题
⽤C语⾔解决迷宫问题#include <stdio.h>#include <stdlib.h>#define ROW 10#define COL 10/*迷宫中位置信息*/typedef struct position{int x;int y;}position;/*在迷宫中的当前位置的信息，也是⼊栈的基本元素*/typedef struct SElem{int di;position seat;}SElem;/*链式栈中节点的定义*/typedef struct position_stack{SElem p;struct position_stack *next;}*Stack_pNode,Stack_Node;void InitStack(Stack_pNode *Link){*Link = NULL;}void push(Stack_pNode *Link,SElem e){Stack_pNode new_SElem = (Stack_pNode)calloc(1,sizeof(Stack_Node));new_SElem->p = e;new_SElem->next = NULL;if (*Link == NULL)*Link = new_SElem;else{new_SElem->next = *Link;*Link = new_SElem;}}int pop(Stack_pNode *Link,SElem *e){if (*Link == NULL)return 0;*e = (*Link)->p;Stack_pNode q = *Link;*Link = (*Link)->next;free(q);return 1;}int top(Stack_pNode Link, SElem *e){if (Link == NULL)return 0;*e = Link->p;return 1;}int empty(Stack_pNode Link){if (Link == NULL)return 1;elsereturn 0;}int reverse(Stack_pNode *Link){Stack_pNode p, q, r;if (*Link == NULL || (*Link)->next == NULL)return 0;r = *Link;p = (*Link)->next;q = NULL;while (p){r->next = q;q = r;r = p;p = p->next;}r->next = q;*Link = r;}void print(Stack_pNode Link){Stack_pNode r = Link;while (r){printf("(%d,%d) -> ",r->p.seat.x,r->p.seat.y);r = r->next;}printf("exit\n");}int curstep = 1;/*纪录当前的⾜迹，填写在探索前进的每⼀步正确的路上*//*迷宫地图。
c语言~走迷宫
本程序代码为C语言解决数据结构（严蔚敏）中关于迷宫的问题。
程序不仅实现迷宫路径查找，还实现文字描述路径功能可以直接粘贴到vc6.0中运行【代码如下】# include <stdio.h> # include <malloc.h> # define null 0typedef 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当中寻找mazepahtvoid 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(){sqlist mazepath;creatstack(&mazepath); //创建一个存储路径的栈int mazemap[10][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};// creatmap(mazemap); //创建迷宫图纸printf("迷宫原图为：\n");printmap(mazemap);findpath(mazemap,&mazepath); //在mazemap当中寻找mazepaht printf("走出迷宫图纸为：\n");printmap(mazemap);printf("走出迷宫文字叙述为：\n");roadinwords(&mazepath);// printpath(&mazepath);}void findpath(int (*mazemap)[10],sqlist *mazepath){int x,y,flag=0,k=0,next; //位置是否可通，flag=0通，1墙，2通但不可走x=1;y=1; //获取初始位置push(x,y,mazepath); //起点位置进栈footprint(x,y,6,mazemap);while(flag==0 && k!=162) //flag==1到达终点,0未到达终点{if(passroad(x,y+1,mazemap)==0)push(x,y+1,mazepath),y=y+1,footprint(x,y,6,mazemap);else if(passroad(x+1,y,mazemap)==0)push(x+1,y,mazepath),x=x+1,footprint(x,y,6,mazemap);else if(passroad(x,y-1,mazemap)==0)push(x,y-1,mazepath),y=y-1,footprint(x,y,6,mazemap);else if(passroad(x-1,y,mazemap)==0)push(x-1,y,mazepath),x=x-1,footprint(x,y,6,mazemap);elsefootprint(x,y,2,mazemap),pop(mazepath),gettop(mazepath),x=topelem[0],y= topelem[1];// printmap(mazemap);k++;flag=position(x,y); //判断是否到达终点// printf("flag==%d\n",flag);}}void creatstack(sqlist *mazepath){mazepath->base=(int (*)[2])malloc(120*sizeof(int (*)[2]));mazepath->top=mazepath->base;mazepath->listlen=120;}void push(int x,int y,sqlist *mazepath){**(mazepath->top)=x;*(*(mazepath->top)+1)=y;mazepath->top++;}void pop(sqlist *mazepath){if(mazepath->top!=mazepath->base)mazepath->top--;}void printmap(int (*mazemap)[10]){int (*p)[10];p=mazemap;int i,j;printf(" \n\n\n");for(i=0;i<10;i++){for(j=0;j<10;j++){if(j==0)printf(" ");if(*(*(p+i)+j)==0)printf("▇");else if(*(*(p+i)+j)==1)printf("□");else if(*(*(p+i)+j)==6)printf("★");elseprintf("▇");if(j==9)printf("\n");}}printf("\n\n");}void printpath(sqlist *mazepath){int (*p)[2];p=mazepath->base;while(p!=mazepath->top){printf("x=%d,y=%d\n",**p,*(*p+1));p++;}}void gettop(sqlist *mazepath){int (*p)[2];int (*q)[2];p=mazepath->base;while(p!=mazepath->top){q=p;p++;}topelem[0]=**q;topelem[1]=*(*q+1);}void footprint(int x,int y,int k,int (*mazemap)[10]){if(x<10 && y<10)*(*(mazemap+x)+y)=k;}int position(int x,int y){int flag;if(x==8 && y==8)flag=1;elseflag=0;return(flag);}int passroad(int x,int y,int (*mazemap)[10]) {int num=1;if(x<10 && y<10)num=*(*(mazemap+x)+y);return(num);}void roadinwords(sqlist *mazepath){int x=1,y=1,i=0;int (*p)[2];p=mazepath->base;p++;while(p!=mazepath->top){if(x==**p && y+1==*(*p+1))printf("向右走→→"),x=**p,y=*(*p+1);else if(x+1==**p && y==*(*p+1))printf("向下走→→"),x=**p,y=*(*p+1);else if(x==**p && y-1==*(*p+1))printf("向左走→→"),x=**p,y=*(*p+1);else if(x-1==**p && y==*(*p+1))printf("向上走→→"),x=**p,y=*(*p+1);i++;if(i%3==0)printf("\n");p++;}printf("\n");}。
迷宫游戏C语言程序课程设计
printf("");
if(chMap[i][j]==2)
prin tf("E");
}
}
if(chMap[y-5][x-10]==2)/*如果如果人的坐标和目标坐标重合输出"YOU WIN!"退出*/
clrscr();
printf("You Win!");
break;
}
/*返回ASCII码或扩充码*/
void main()
{
int iKey,x=11,y=6;/*x,y为人物移动后坐标*/
int chMap[10][10]={/*用二维数组定义地图*/
{0,0,0,0,0,0,0,0,0,0},/*0表示墙1表示路2表示出口*/
{0,1,0,0,1,1,1,1,1,0},
{0,1,1,0,1,0,1,0,1,0},
{0,0,1,0,1,0,1,0,1,0},
{0,0,1,1,1,0,0,0,1,0},
{0,0,0,0,0,0,1,1,1,0},
{0,1,0,0,1,1,1,0,0,0},
{0,1,1,1,1,0,0,0,2,0},
{0,1,0,0,1,1,1,1,1,0},
}；
int fnGetKey(void)
{
union keyboard uniKeyl; while(bioskey(1)==0); uniKey1.iKeylnfo=bioskey(0);
/*
/*
/*
/*
/*
return(uniKey1.chKeyBit[0]==0?uniKey1.chKeyBit[1]:uniKey1.chKeyBit[0]);
c语言迷宫问题代码实现
structStackList
{
SEAT stack[MAXSIZE];
inttop;
}*Stack;
intEmptyStack(StackList*Stack)//判断是否为空栈
{
if(Stack->top==0)
return 0;
else
return 1;
}
intMove[4][2]={{0,1},{1,0},{0,-1},{-1,0}};//分别表示向东、西、南、北需要加上的坐标
CurSeat=temp;
find =1;
}
}
}
}
}while(EmptyStack(Stack));
return false;
}
voidPrintStack(StackList*Stack)//输出路线
{
if(Stack->top==0)
printf("There is no route can be out of the maze\n");
Mark(CurSeat);
if(CurSeat.x==end.x+1&&CurSeat.y==end.y+1)//如果找到出口，返回
{
return true;
}
else
{
intfind=0;
while(CurSeat.di<3&&find==0)//找下一个结点的方向
{
CurSeat.di++;
SEAT temp;
scanf("%d",&n);
printf("Please enter the labyrinth of the coordinates of the wall unit(0<=row,column):\n");
用c语言实现迷宫求解完美源代码
优先队列：用于存储待扩展节点，按照 f(n)值从小到大排序
A*搜索算法的C语言实现
算法流程：包括初始化、搜索、更新父节点等步骤 数据结构：使用优先队列来存储待搜索节点和已访问节点 实现细节：包括如何计算启发式函数、如何选择下一个节点等 性能优化：可以采用多线程、缓存等技术来提高算法的效率
A*搜索算法在迷宫求解中的应用
C语言实现A*搜 索算法
A*搜索算法的基本原理
定义：A*搜索算法是一种启发式搜索 算法，结合了最佳优先搜索和Dijkstra 算法的优点
基本思想：使用启发函数来评估节点的 重要性，优先选择最有希望的节点进行 扩展，从而有效地缩小搜索范围
关键参数：g(n)：从起点经过节点n的 实际代价；h(n)：从n到目标的估计代 价（启发式函数）；f(n)=g(n)+h(n)
最短路径搜索
优化技巧：为了 提高搜索效率和 精度，可以采用 一些优化技巧， 如限制搜索范围、 使用优先队列等
C语言实现 Dijkstra算法
Dijkstra算法的基本原理
Dijkstra算法是一种用于求解最短路径问题的贪心算法 该算法通过不断选择当前最短路径的节点来逼近最短路径 Dijkstra算法适用于带权重的图，其中权重表示节点之间的距离 Dijkstra算法的时间复杂度为O((V+E)logV)，其中V是节点数，E是边数
算法复杂度分析：时间复杂 度和空间复杂度分析
感谢您的观看
汇报人：XX
迷宫求解算法的C语言实现流程
初始化迷宫和路径
定义四个方向的移动方向
遍历迷宫，找到起点和终点
使用深度优先搜索或广度优先 搜索算法求解路径
C语言实现深度 优先搜索算法
深度优先搜索算法的基本原理
c语言走迷宫代码
c语言走迷宫代码以下是一个简单的 C 语言走迷宫代码示例，使用了递归算法: ```c#include <stdio.h>#include <stdlib.h>int main() {int size, row, col, choice, i, j;maze[0][0] = "*";maze[1][0] = "O";maze[0][1] = "O";maze[1][1] = "*";size = 2;row = 2;col = 2;while (1) {printf("Enter row: ");scanf("%d", &row);printf("Enter col: ");scanf("%d", &col);if (row < 0 || row > size || col < 0 || col > size) { printf("Invalid row or col. Try again.");}if (maze[row][col] != "*") {printf("Current cell is free. Try again. ");continue;}maze[row][col] = "X";printf("Enter a choice (1-6): ");scanf("%d", &choice);switch (choice) {case 1:row++;col = 0;break;case 2:row--;col = 0;break;case 3:col++;break;col--;break;case 5:row--;col = 1;break;case 6:row++;col = 1;break;default:printf("Invalid choice. Try again. ");continue;}}printf(" maze: ");for (i = 0; i < size * size; i++) { for (j = 0; j < size; j++) {if (maze[i][j] == "*")printf("*");elseprintf("%c", maze[i][j]);}printf("");}return 0;}```该程序首先初始化了一个 2x2 的迷宫，其中 `maze[0][0]` 和`maze[1][0]` 分别标记为 `"O"` 和 `"*"`,其他地方都为空。
C语言迷宫程序
基于栈的C语言迷宫问题与实现一．问题描述多年以来，迷宫问题一直是令人感兴趣的题目.实验心理学家训练老鼠在迷宫中寻找食物.许多神秘主义小说家也曾经把英国乡村花园迷宫作为谋杀现场。
于是，老鼠过迷宫问题就此产生,这是一个很有趣的计算机问题,主要利用“栈”是老鼠通过尝试的办法从入口穿过迷宫走到出口。
迷宫只有两个门，一个叫做入口,另一个叫做出口。
把一只老鼠从一个无顶盖的大盒子的入口处赶进迷宫.迷宫中设置很多隔壁，对前进方向形成了多处障碍，在迷宫的唯一出口处放置了一块奶酪，吸引老鼠在迷宫中寻找通路以到达出口。
求解迷宫问题，即找出从入口到出口的路径.一个迷宫可用上图所示方阵[m，n]表示,0表示能通过，1 表示不能通过。
现假设耗子从左上角［1,1]进入迷宫，编写算法，寻求一条从右下角［m，n] 出去的路径。
下图是一个迷宫的示意图：迷宫示意图二．算法基本思想迷宫问题是栈应用的一个典型例子。
求解过程可采用回溯法.回溯法是一种不断试探且及时纠正错误的搜索方法。
从入口出发,按某一方向向前探索，若能走通（未走过的），即某处可以到达，则到达新点，否则试探下一方向；若所有的方向均没有通路，则沿原路返回前一点，换下一个方向再继续试探,直到所有可能的通路都探索到，或找到一条通路，或无路可走又返回到入口点。
在求解过程中，为了保证在到达某一点后不能向前继续行走（无路）时，能正确返回前一点以便继续从下一个方向向前试探，则需要用一个栈保存所能够到达的每一点的下标及从该点前进的方向，栈中保存的就是一条迷宫的通路。
为了确保程序能够终止,调整时，必须保证曾被放弃过的填数序列不被再次试验,即要求按某种有序模型生成填数序列.给解的候选者设定一个被检验的顺序,按这个顺序逐一生成候选者并检验。
三．主要数据结构1.方阵栈：＃define STACK_INI_SIZE 100typedef struct｛int ＊top；//指向栈的顶端域int ＊base; //指向栈的低端域int length; //栈的长度int stacksize; //栈的最大长度｝sqstack；2．产生迷宫的矩阵二维数组为了使每一个迷宫存在迷宫的边界和两个端口：入口、出口，设置了一个二维数组，在迷宫的周边定义为1，使得迷宫存在边界，并在（1，1）,（x—2,y—2）初定义为0,即定义迷宫的出口,大大减小了无解的情况。
C语言迷宫源代码
#include <graphics.h>#include <stdlib.h>#include <bios.h>/*定义几个功能按键*/#define ESC 0x11b /*强行退出游戏*/#define UP 0x4800 /*上下左右四个按键移动小人*/#define DOWN 0x5000#define LEFT 0x4b00#define RIGHT 0x4d00int a[50][50]={0}; /* 存放地图信息的数组0：不可走的障碍物1：可以走的路*/ int qdx=1,qdy=1,zdx=20,zdy=20; /* 起点和终点的坐标*/int renx,reny; /* 小人坐标*/int d=20; /* 小格子的间距*/int kk=0,rr=2;main(){int i,j,m=30,n=16,d=20,k;int gdriver = DETECT, gmode;randtu(200);renx=qdx,reny=qdy;registerbgidriver(gdriver);initgraph(&gdriver, &gmode, "c:\\turboc2");redraw();while(1) /* 反复从键盘获得程序需要的按键*/{if(bioskey(1)) /* 判断是否有按键*/{k=bioskey(0); /* 将按键存入变量k */switch(k) /* 对按键进行分情况处理*/{case ESC: /* ESC键退出*/printf("%d times\n",kk);exit(0); break;case UP: /* UP键向上移动光标*/if(a[renx][reny-1]==1){reny-=1;redraw();}break;case DOWN: /* DOWN键向下移动光标*/if(a[renx][reny+1]==1){reny+=1;redraw();}break;case LEFT: /* LEFT键向左移动光标*/if(a[renx-1][reny]==1){renx-=1;redraw();}break;case RIGHT: /* RIGHT键向右移动光标*/if(a[renx+1][reny]==1){renx+=1;redraw();}break;}}}getch();closegraph();}/*redraw重画函数在用户有操作后，重画游戏画面*/redraw(){int i,j;for(i=qdx;i<=zdx;i++)for(j=qdy;j<=zdy;j++){if(i<renx+rr && i>renx-rr && j<reny+rr && j>reny-rr)if(a[i][j]==0) geziza(i*d,j*d);else gezilu(i*d,j*d);else gezibk(i*d,j*d);}drawren(renx*d,reny*d);}/*随机地图（randlei）函数用于随机生成地图*/randtu(int num){int i,j,xx,yy,sum,t,m,n;srand(time(NULL));loop: sum=0;m=zdy-qdy+1;n=zdx-qdx+1;a[qdx][qdy]=1;a[zdx][zdy]=1;do{t=random(m*n);xx=t/m+1;yy=t%m+1;if(a[xx][yy]==0){a[xx][yy]=1;sum++;}}while(sum<num);if(ok()) return;for(i=0;i<50;i++)for(j=0;j<50;j++)a[i][j]=0;kk++;goto loop;}ok(){ int b[50][50]={0};b[qdx][qdy]=1;tansuo(qdx,qdy,b);return(b[zdx][zdy]);}tansuo(int x,int y,int *b[50][50]) /* 如果当前格子为空白无雷情况，向周围探索相类似的情况，并打开周围的数字*/{if(a[x][y-1]==1 && b[x][y-1]==0){b[x][y-1]=1;tansuo(x,y-1,b);}if(a[x+1][y]==1 && b[x+1][y]==0){b[x+1][y]=1;tansuo(x+1,y,b);}if(a[x-1][y]==1 && b[x-1][y]==0){b[x-1][y]=1;tansuo(x-1,y,b);}if(a[x][y+1]==1 && b[x][y+1]==0){b[x][y+1]=1;tansuo(x,y+1,b);}}/*绘制障碍物小格子（geziza）int x : 格子左上角点横坐标int y ：格子左上角点纵坐标*/geziza(int x,int y){int i;setcolor(8);rectangle(x,y,x+d,y+d);setcolor(RED);setfillstyle(2,RED);bar(x+1,y+1,x+d-1,y+d-1);/* 设置深灰色为格子边框*/ }/*绘制障碍物小格子（geziza）int x : 格子左上角点横坐标int y ：格子左上角点纵坐标*/gezibk(int x,int y){int i;setcolor(8);rectangle(x,y,x+d,y+d);setcolor(BLUE);setfillstyle(2,BLUE);bar(x+1,y+1,x+d-1,y+d-1);/* 设置深灰色为格子边框*/}gezilu(int x,int y){int i;setcolor(8); /* 设置深灰色为格子边框*/ rectangle(x,y,x+d,y+d);setcolor(BLUE);setfillstyle(8,BLUE);bar(x+1,y+1,x+d-1,y+d-1);}/*画小人（drawren）函数用于绘制给定坐标位置的小人小人画在格子的正中心格子背景色为红色int x : 所在格子左上角点横坐标int y ：所在格子左上角点纵坐标*/drawren(int x,int y){int i;setcolor(8); /* 设置深灰色为格子边框*/ rectangle(x,y,x+d,y+d);setcolor(YELLOW);for(i=1;i<d/2-3;i++)circle(x+d/2,y+d/2,i);}/*over（over）函数用于判断游戏是否结束*/over(){}。
迷宫(C语言版)
/*注：本程序探索迷宫的优先顺序=> 1-下、2-右、3-上、4-左<=总体趋势：下右，逆时针方向。
因为出口就在右边下方*/#include<stdio.h>#include<stdlib.h>#include<time.h>#define stack_init_size 200#define stack_increment 10#define OVERFLOW 0#define OK 1#define ERROE 0#define TRUE 1#define FALSE 0typedef 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++)for(j=1;j<19;j++){k=rand()%3; //随机生成0、1、2三个数if(k)mg[i][j]=0;else{if((i==1&&j==1)||(i==18&&j==18)) /*因为距入口或出口一步的路是必经之路，故设该通道块为“0”加大迷宫能通行的概率*/mg[i][j]=0;elsemg[i][j]=1;}}}//构造一个空栈Status InitStack(SqStack &s){s.base =(SElemType *)malloc(stack_init_size *sizeof(SElemType));if(!s.base) return OVERFLOW;s.top=s.base;s.stacksize=stack_init_size;return OK;}//当前块可否通过Status Pass(PosType e){if (mg[e.x][e.y]==0) //0时可以通过return OK; // 如果当前位置是可以通过，返回1return OVERFLOW; // 其它情况返回0}//留下通过的足迹Status FootPrint(PosType e){mg[e.x][e.y]=7;return OK;}//压入栈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 ERROE;e=*--s.top;return OK;}//下一步PosType NextPos(PosType &e,int dir){ PosType E;switch(dir){case 1:E.x=e.x; //向下E.y=e.y+1;break;case 2:E.x=e.x+1; //向右E.y=e.y;break;case 3:E.x=e.x; //向上E.y=e.y-1;break;case 4:E.x=e.x-1; //向左E.y=e.y;break;}return E;}//是否空栈Status StackEmpty(SqStack s){if (s.top==s.base)return OK;return OVERFLOW;}//留下不能通过的足迹Status MarkPrint(PosType e){mg[e.x][e.y]=3;return OK;}//迷宫函数// 若迷宫maze中从入口start到出口end的通道，则求得一条存放在栈中// （从栈底到栈顶），并返回TRUE；否则返回FALSEStatus MazePath(int mg,PosType start,PosType end,SqStack &s){PosType curpos;InitStack(s);SElemType e;int curstep;curpos=start; // 设定"当前位置"为"入口位置"curstep=1; // 探索第一步do{if(Pass(curpos)){// 当前位置可通过，即是未曾走到过的通道块FootPrint(curpos); // 留下足迹e.di =1;e.ord = curstep;e.seat= curpos;Push(s,e); // 加入路径if(curpos.x==end.x&&curpos.y==end.y){printf("\n\n0∩_∩0 能到达终点!");return TRUE;}curpos=NextPos(curpos,1); // 下一位置是当前位置的东邻curstep++; // 探索下一步}else{// 当前位置不能通过if(!StackEmpty(s)){Pop(s,e);while(e.di==4&&!StackEmpty(s)){MarkPrint(e.seat);Pop(s,e);}if(e.di<4){e.di++;Push(s,e); // 留下不能通过的标记，并退回一步curpos=NextPos(e.seat,e.di); /* 当前位置设为新方向的相邻块*/}//if}//if}//else}while(!StackEmpty(s));printf("\n\n囧! 不能到达终点!");return FALSE;}//打印迷宫void PrintMaze(){int i,j;printf("运行路径:\n\n");for(i=0;i<20;i++){for(j=0;j<20;j++){if(mg[i][j]==0)printf(" ");else if(mg[i][j]==1) printf("■"); //迷宫的“墙”else if(mg[i][j]==3) printf("◇"); //不通的路else if(mg[i][j]==7)printf("○"); //通过的路径}printf("\n");}printf("\n");}void main(){SqStack S;PosType start,end;start.x=1;start.y=0; //起点坐标end.x=18;end.y=19; //终点坐标printf("\n==================迷宫游戏==================");printf("\n说明:■不能走的区域\t◇走不通的区域");printf("\n “空格”代表未到过的区域");printf("\n ○代表能通过的路径，指向终点");printf("\n============================================");Random();printf("\n\nTest 1:");MazePath(mg[20][20],start,end,S);PrintMaze();system("pause");Random();printf("\nTest 2:");MazePath(mg[20][20],start,end,S);PrintMaze();system("pause");Random();printf("\nTest 3:");MazePath(mg[20][20],start,end,S);PrintMaze();printf("\n==========程序退出，感谢使用!==========\n");}。
c语言生成随机迷宫并闯关
dir=rand()%2+2;}
else{
if(z==1){//限制边线处的发展方向
dir=rand()%3;
if(dir==2){dir=3;}}
else{
if(v==1){
case 1:printf(" ");break;
}
}
printf("\n");
}
return 0;
}
int chushihua(){//偷懒用循环给二维数组每个元素赋值
for(y=0;y<h;y++){
for(x=0;x<w;x++){
dir=rand()%2;
}
else{
if(z==1&&h-v==2){
dir=rand()%2;
if(dir==1){
dir=3;}
}
else{
if(w-z==2&&v==1){
dir=rand()%2+1;}
else{
dir=rand()%3;}
else{
if(w-z==2){
dir=rand()%3+1;}
else{
if(h-v==2){
dir=rand()%3+1;
if(dir==1){dir=0;}}
int lv;//难度
int qxs(){//迷宫全部显示
for(y=0;y<h;y++){
for(x=0;x<w;x++){
迷宫(direction)C语言代码
};
mazePath(maze,direction,1,1,6,9);
getchar();
return 0;
}
#include<stdio.h>
#include<conio.h>
intmigong[10][10]= //设置迷宫，最外围1为墙 里边0为可走路径 1为障碍
voidpush_seq(PSeqStackpastack,DataTypex ) {
if(pastack->t >= MAXNUM - 1 )
printf( "Overflow! \n" );
else {
pastack->t++;
pastack->s[pastack->t] = x;
}
}
/* 删除栈顶元素 */
element =top_seq(st);
pop_seq(st);
i=element.x; j =element.y;
for (k =element.d+ 1; k <= 3; k++) { /* 依次试探每个方向 */
g =i+ direction[k][0];h = j + direction[k][1];
lj[top].x=1;
lj[top].y=1;
migong[1][1]=-1;
find=0;d=-1;
while(top>-1){
if(lj[top].x==8&&lj[top].y==8)
{
printf("迷宫路径如下：\n");
c语言版 迷宫 完整版代码
line(500,200,450,250);
outtextxy(445,270,"z");
line(500,200,550,250);
case 7: (*y)--;break; /*左*/
case 8: (*x)--;(*y)--;break; /*左上*/ }
setfillstyle(SOLID_FILL,RED);/*新位置显示探索物*/
bar(100+(*y)*15-6,50+(*x)*15-6,100+(*y)*15+6,50+(*x)*15+6); }
else if(c=='x'&&map[x+1][y]!=1) DrawPeople(&x,&y,5);/*下*/
else if(c=='z'&&map[x+1][y-1]!=1) DrawPeople(&x,&y,6); /*左下*/
WayCopy(oldmap,map);
if(oldmap[i+1][j]==0&&!yes)/*判断下方是否可以走,如果标志yes已经是1也不用找下去了*/
{ FindWay(oldmap,i+1,j);
{ FindWay(oldmap,i,j+1);
if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }
WayCopy(oldmap,map);
#include <graphics.h>
c语言迷宫代码
c语言迷宫代码C语言迷宫代码是指用C语言编写的程序，用于生成和解决迷宫问题的算法。
迷宫通常由一个矩形网格组成，其中包含墙壁和通道。
目标是找到从迷宫的起点到终点的路径，同时避开墙壁。
下面是一个简单的示例代码，用于生成迷宫：```c#include <stdio.h>#include <stdlib.h>#include <stdbool.h>#define ROWS 10#define COLS 10typedef struct {int x;int y;} Point;void generateMaze(int maze[ROWS][COLS]) {for (int i = 0; i < ROWS; i++) {for (int j = 0; j < COLS; j++) {if (i % 2 == 0 || j % 2 == 0) { maze[i][j] = 1; // 墙壁} else {maze[i][j] = 0; // 通道}}}}void printMaze(int maze[ROWS][COLS]) {for (int i = 0; i < ROWS; i++) {for (int j = 0; j < COLS; j++) {printf('%d ', maze[i][j]);}printf('');}}int main() {int maze[ROWS][COLS];generateMaze(maze);printMaze(maze);return 0;}```在上面的代码中，我们使用一个二维数组来表示迷宫。
数组中的值为1表示墙壁，值为0表示通道。
使用generateMaze函数，我们将迷宫的墙壁和通道初始化为适当的值。
然后使用printMaze函数打印迷宫。
通过运行上面的代码，我们可以得到一个简单的迷宫的表示：```1 1 1 1 1 1 1 1 1 11 0 1 0 1 0 1 0 1 11 1 1 1 1 1 1 1 1 11 0 1 0 1 0 1 0 1 11 1 1 1 1 1 1 1 1 11 0 1 0 1 0 1 0 1 11 1 1 1 1 1 1 1 1 11 0 1 0 1 0 1 0 1 11 1 1 1 1 1 1 1 1 11 0 1 0 1 0 1 0 1 1```当然，上述代码只是生成了一个简单的迷宫，还没有解决迷宫问题。
迷宫游戏C语言小游戏源代码
PosType NextPos(PosType seat,i nt di);
Status MazePath(PosType start,PosType end);
void CreatMaze(void)
/* Forቤተ መጻሕፍቲ ባይዱ the maze. */
case ''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''：Maze[j][k]=2・break・
case ''''''''''''''''''''''''''''''''3''''''''''''''''''''''''''''''''：Maze[j][k]=1・
基于C语言实现的迷宫算法示例
基于C语⾔实现的迷宫算法⽰例本⽂实例讲述了基于C语⾔实现的迷宫算法。
分享给⼤家供⼤家参考，具体如下：利⽤c语⾔实现迷宫算法，环境是vc++6.0.#include<stdio.h>#include<time.h>#include<cstdlib>int visit(int,int);void setmaze();int maze[11][11]={{0,0,2,2,2,2,2,2,2,2},{2,0,2,2,0,2,0,2,0,2},{2,0,2,0,0,0,0,0,0,2},{2,0,2,2,2,0,2,0,0,2},{2,0,0,0,0,0,2,2,0,2},{2,2,0,2,2,0,2,2,0,2},{2,2,2,0,0,0,0,0,0,2},{2,0,2,0,2,0,2,2,0,2},{2,0,0,0,0,2,0,2,0,0},{2,2,2,2,2,2,2,2,2,2}};int startI,startJ; //定义⼊⼝变量int endI,endJ; //定义出⼝变量int success=0; //定义返回变量int p;void setStart() // 设置⼊⼝{printf("请设置迷宫⼊⼝（i,j）:");scanf("%d,%d",&startI,&startJ);}void setEnd() // 设置出⼝{printf("请设置迷宫出⼝（i,j）:");scanf("%d,%d",&endI,&endJ);}void setmaze() //设置迷宫图{int i,j,a,p;for(i=0;i<10;i++)for(j=0;j<10;j++){p=rand()%2;if(p==0) a=0;else a=2;maze[i][j]=a;}}void DisplayMaze() //打印迷宫{int i,j;for(i=0;i<10;i++){printf(" ");for(j=0;j<10;j++)if(maze[i][j]==2) printf("##"); //打印墙壁else printf(" "); //打印路径printf("/n");}}void Maze_PS() //输出迷宫路径{int i,j;if(visit(startI,startJ)==0) //寻找路径printf("/n没有找到出⼝！/n");else{maze[startI][startJ]=8;//设置⼊⼝标志maze[endI][endJ]=9;//设置出⼝标志printf("/n显⽰路径：/n");for(i=0;i<10;i++){for(j=0;j<10;j++){if(maze[i][j]==8) printf("☆");//标志⼊⼝else if(maze[i][j]==9) printf("○");//标志出⼝else if(maze[i][j]==2) printf("##"); //表⽰墙壁else if(maze[i][j]==1) printf(" >"); //表⽰路径else printf(" "); //通路}printf("/n");}}}int visit(int i,int j) //寻找迷宫路径函数，找到路径返回1，找不到路径返回0{maze[i][j]=1;if((i==endI)&&(j==endJ)) success=1; //找到出⼝，返回值success为1if((success!=1)&&(maze[i][j+1]==0)) visit(i,j+1); //检测右⾯通路，若通，向右移动 if((success!=1)&&(maze[i+1][j]==0)) visit(i+1,j); //检测下⾯通路，若通，向下移动 if((success!=1)&&(maze[i][j-1]==0)) visit(i,j-1); //检测左⾯通路，若通，向左移动 if((success!=1)&&(maze[i-1][j]==0)) visit(i-1,j); //检测上⾯通路，若通，向上移动 if(success!=1) maze[i][j]=0; //退回，⾃⾝标为0return success;}main(void) //主函数{int c1,c2;for(c2=1;c2==1;){srand(time(0));printf("显⽰迷宫：/n");for(c1=1;c1==1;){DisplayMaze();printf("按'1'输出新迷宫,'2'开始求解路径：/n");scanf("%d",&c1);rewind(stdin);//清除输⼊缓冲区if(c1==1) setmaze() ;}if(c1!=1&&c1!=2) {printf("Error!!/n");break;}setStart();setEnd();Maze_PS();printf("Continue?(1 to continue,2 to exit.1)");scanf("%d",&c2);if(c2==1) setmaze();else break;}system("pause");}希望本⽂所述对⼤家C语⾔程序设计有所帮助。
c语言迷宫代码
if(tt.l<min) min = tt.l;//最短路径更新
temp = s;
push(&p, tt);//从终点到起点依次入栈p，保存路径
push(&p, t);
while(!empty(&temp))
{
pop(&temp, &tt);
push(&p,tt);
}
step=0;
while(!empty(&p))//从起点到终点依次出栈p，输出路径
{
pop(&p, &tt);
if(step==0) step=1;
else printf(" -> ");
printf("(%d,%d)",tt.x,tt.y);
}
printf("\n");
if(map[i][j] == 'S') sx=i, sy=j;//寻找起点坐标
if(map[i][j] == 'E') ex=i, ey=j;//寻找终点坐标
}
}
dfs();//搜索路径
printf("路径总数：%d\n", num);//输出路径总数
if(num > 0)//若存在可行路径，输出最短、最长路径长度
{
printf("最短路径：%d\n", min);
printf("最长路径：%d\n", max);
}
}
{
datatype data[Maxn];//栈数据
基于C语言实现简单的走迷宫游戏
基于C语⾔实现简单的⾛迷宫游戏本⽂实例讲述了C语⾔实现简单的⾛迷宫游戏的⽅法，代码完整，便于读者理解。
学数据结构时⽤“栈”写的⼀个⾛迷宫程序，实际上⽤到双向队列，⽅便在运⾏完毕后输出经过的点。
#include <cstdio>#include <deque>#include <windows.h>using namespace std;class node{public:int x,y;int lastOpt;};deque<node> sta;int x,y;int endx,endy;int mapW,mapH;int steps;int xopt[5]= {0,0,1,0,-1};int yopt[5]= {0,1,0,-1,0};int map[100][100]={};void init(){x = 1;y = 1;endx = 1;endy = 9;mapH = 10;mapW = 10;for(int i=0; i<=mapH; i++)for(int j=0; j<=mapW; j++){if(i==0 ||j==0 ||i==mapH||j==mapW)map[i][j]=-1;}steps=0;map[1][2]=-1;map[2][2]=-1;map[3][2]=-1;map[4][2]=-1;map[6][2]=-1;map[7][2]=-1;map[8][2]=-1;map[9][2]=-1;map[9][3]=-1;map[8][3]=-1;map[1][4]=-1;map[3][4]=-1;map[4][4]=-1;map[5][4]=-1;map[6][4]=-1;map[7][4]=-1;map[1][6]=-1;map[2][6]=-1;map[3][6]=-1;map[4][6]=-1;map[5][6]=-1;map[6][6]=-1;map[7][6]=-1;map[8][6]=-1;map[8][7]=-1;map[8][8]=-1;map[7][8]=-1;map[6][8]=-1;map[5][8]=-1;map[4][8]=-1;map[2][8]=-1;map[1][8]=-1;map[endx][endy]=5;}void dis(){system("cls");int ori = map[x][y];map[x][y]=1;for(int i=0; i<=mapH; ++i){for(int j=0; j<=mapW; ++j){if(map[i][j]==0)printf(" ");else if(map[i][j]==-1)printf(" #");else if(map[i][j]==1)printf(" @");else if(map[i][j]==2)printf(" .");else if(map[i][j]==5)printf(" !");}cout<<i<<endl;}for(int j=0; j<=mapW; ++j)cout<<j<<" ";printf("\n\n > steps:%d Exit:(%d,%d)\n",steps,endx,endy);map[x][y] = ori;}int can(int n){if(map[x+xopt[n]][y+yopt[n]] == 0 || map[x+xopt[n]][y+yopt[n]] == 5) return 1;return 0;}void visit(int n){map[x][y]=2;x+=xopt[n];y+=yopt[n];node tem;tem.x = x;tem.y = y;stOpt = n;sta.push_back(tem);steps++;}int main(){init();node tem;while( x != endx || y!=endy){int cans = 0;for(int i=1; i<=4; i++){if(can(i)){cans = 1;visit(i);break;}}if(!cans){if(!sta.empty()){tem = sta.back();map[tem.x][tem.y]=0;}else{map[x][y]=2;x+=xopt[stOpt];x+=yopt[stOpt];dis();break;}}dis();Sleep(500);}if(x==endx && y == endy)cout<<"\n > i am finished....\n";elsecout<<"\n > i am finished...but i can't find the right way\n";return 0;}效果图：以上就是本⽂的全部内容，希望对⼤家学习C语⾔有所帮助。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
基于栈的C语言迷宫问题与实现
一. 问题描述
多年以来，迷宫问题一直是令人感兴趣的题目。
实验心理学家训练老鼠在迷宫中寻找食物。
许多神秘主义小说家也曾经把英国乡村花园迷宫作为谋杀现场。
于是，老鼠过迷宫问题就此产生, 这是一个很有趣的计算机问题，主要利用“栈”是老鼠通过尝试的办法从入口穿过迷宫走到岀口。
迷宫只有两个门，一个叫做入口，另一个叫做岀口。
把一只老鼠从一个无顶盖的大盒子的入口处赶进迷宫。
迷宫中设置很多隔壁，对前进方向形成了多处障碍，在迷宫的唯一岀口处放置了
一块奶酪，吸引老鼠在迷宫中寻找通路以到达出口。
求解迷宫问题，即找出从入口到出口的路径。
一个迷宫可用上图所示方阵［m,n］表示，0表示能通过，1表示不能通过。
现假设耗子从左上
角［1,1］进入迷宫，编写算法，寻求一条从右下角［m,n］岀去的路径。
下图是一个迷宫的示意图：
算法基本思想
迷宫问题是栈应用的一个典型例子。
求解过程可采用回溯法。
回溯法是一种不断试探且及时纠正错误的搜索方法。
从入口岀发，按某一方向向前探索，若能走通（未走过的），即某处可以到达，则到达新点，否则试探下一方向；若所有的方向均没有通路，则沿原路返回前一点，换
下一个方向再继续试探，直到所有可能的通路都探索到，或找到一条通路，或无路可走又返回到
入口点。
在求解过程中，为了保证在到达某一点后不能向前继续行走（无路）时，能正确返回前一点以便继续从下一个方向向前试探，则需要用一个栈保存所能够到达的每一点的下标及从该点前进
的方向，栈中保存的就是一条迷宫的通路。
为了确保程序能够终止，调整时，必须保证曾被放弃过的填数序列不被再次试验，即要求按
迷宫示意图
1． void initstack(sqstack *s);/* 初始化栈 */ 将栈顶和栈底分别申请一段动态存储空间， 将栈分配长度为 100 的空间， 将栈的原始长度定 义为 2
某种有序模型生成填数序列。
给解的候选者设定一个被检验的顺序，
并检验。
按这个顺序逐一生成候选者
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<x;i++)
for(j=0;j<y;j++)
mg[i][j]=rand()%3;//
产生随机数
四． i=0;
for(j=0;j<y;j++)
{ mg[i][j]=1;
//定义边界
mg[j][i]=1;
} i=y-1;
for(j=0;j<x;j++)
mg[j][i]=1;
i=x-1;
for(j=0;j<y;j++)
mg[i][j]=1;
mg[1][1]=0;
mg[x-2][y-2]=0; //定义边界
//定义出口和入口 主要函数功能。