迷宫求解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("\n");
}
// 由当前位置cur、当前步骤curstep试探下一点
void Try(struct PosType cur,int curstep)
{
int i;
struct PosType next; // 下一个位置
// {行增量,列增量}
};
#define MAXLENGTH 25 // 设迷宫的最大行列为25
typedef int MazeType[MAXLENGTH][MAXLENGTH]; // [行][列]
// 全局变量
struct PosType end; // 迷宫终点位置
MazeType m; // 迷宫数组
1 2
迷宫结构如下:
0 0 0 0
0 -1 0 0
0 -1 -1 0
0 0 0 0
请输入起点的行数,列数:(空格隔开)1 1
请输入终点的行数,列数:(空格隔开)2 2
0 0 0 0
0 1 0 0
0 2 3 0
0 0 0 0
}
printf("迷宫结构如下:\n");
Print(x,y);
printf("请输入起点的行数,列数:(空格隔开)");
scanf("%d%d",&begin.x,&begin.y);
printf("请输入终点的行数,列数:(空格隔开)");
scanf("%d%d",&end.x,&end.y);
c语言迷宫求解课程设计
c语言迷宫求解课程设计一、课程目标知识目标:1. 学生能理解并掌握C语言中数组的使用,以及如何通过数组构建迷宫模型;2. 学生能够运用递归算法实现迷宫的求解过程;3. 学生能够理解并描述迷宫求解过程中所涉及到的算法策略和逻辑。
技能目标:1. 学生能够独立编写C语言代码,构建一个迷宫模型;2. 学生能够运用递归思想,实现迷宫的路径寻找;3. 学生能够通过调试和修改代码,优化迷宫求解算法。
情感态度价值观目标:1. 学生能够培养对编程的兴趣,增强对计算机科学的热爱;2. 学生能够通过团队协作,培养沟通和协作能力,感受合作的重要性;3. 学生能够在面对问题时,保持积极的态度,勇于尝试和克服困难。
课程性质:本课程为实践性较强的编程课程,要求学生在理解理论知识的基础上,动手实践,培养编程技能。
学生特点:考虑到学生处于高年级,具备一定的C语言基础,但对于复杂算法的理解和应用尚需引导。
教学要求:教师需注重理论与实践相结合,引导学生通过实际操作,掌握迷宫求解的编程技巧。
同时,关注学生的情感态度,激发学生的学习兴趣和积极性。
在教学过程中,将目标分解为具体的学习成果,便于后续教学设计和评估。
二、教学内容1. C语言基础回顾:数组的使用,包括一维数组、二维数组的定义、初始化和访问;2. 迷宫模型构建:介绍迷宫的概念,学习如何使用二维数组构建迷宫模型,理解迷宫的基本元素和表示方法;3. 递归算法原理:讲解递归的概念,分析递归算法在迷宫求解中的应用,掌握递归调用的过程和条件;4. 迷宫求解算法:学习深度优先搜索(DFS)算法,探讨其在迷宫求解中的应用,分析算法的优缺点;5. 代码编写与调试:根据教学要求,编写C语言代码实现迷宫模型构建和求解,学习使用调试工具进行代码调试和优化;6. 教学案例分析:分析典型迷宫求解案例,了解不同算法策略的优缺点,培养学生解决问题的能力。
教学内容安排和进度:1. 第一课时:C语言基础回顾,迷宫模型构建;2. 第二课时:递归算法原理,迷宫求解算法介绍;3. 第三课时:代码编写与调试,学生实践操作;4. 第四课时:教学案例分析,学生讨论和总结。
求解迷宫问题 (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{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语言描述如下:6/ 2void 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) /*找到了出口,输出路径*/ {瀠楲瑮?迷宫路径如下:\n);for (k=0;k<=top;k++){printf(\ (%d,%d),Stack[k].i,Stack[k].j); if ((k+1)%5==0) printf(\);}6/ 3printf(\);return;}find=0;while (di<4 && find==0) /*找下一个可走方块*/ { di++;switch(di){case 0:i=Stack[top].i-1;j=Stack[top].j;break;case 1:i=Stack[top].i;j=Stack[top].j+1;break;case 2:i=Stack[top].i+1;j=Stack[top].j;break;case 3:i=Stack[top].i;j=Stack[top].j-1;break;}6/ 4if (mg[i][j]==0) find=1;}if (find==1) /*找到了下一个可走方块*/{Stack[top].di=di; /*修改原栈顶元素的di值*/ top++; /*下一个可走方块进栈*/Stack[top].i=i;Stack[top].j=j;Stack[top].di=-1;mg[i][j]=-1; /*避免重复走到该方块*/}else /*没有路径可走,则退栈*/{ mg[Stack[top].i][Stack[top].j]=0;/*让该位置变为其他路径可走方块*/top--;}}牰湩晴尨没有可走路径!\n);}6/ 5(范文素材和资料部分来自网络,供参考。
用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语言解决迷宫求解问题
迷宫求解
任务:
可以输入一个任意大小的迷宫数据,用非递归的方法求出一条走出迷宫的路
径,并将路径输出。
#include<iostream>
//获取栈顶元素
if(!(p.GetPop().x==q.GetPop().x&&p.GetPop().y==q.GetPop().y))
p.Push(Temp2);
//如果有新位置入栈,则把上一个探索的位置存入栈 p
for(loop=0;loop<4;loop++) //探索当前位置的 4 个相邻位置
//使栈顶元素出栈
T GetPop();
//取出栈顶元素
void Clear();
//把栈清空
bool empty();
//判断栈是否为空,如果为空则返回 1,否则返回 0
};
Stack::Stack()
//构造函数,置空栈
{
top=NULL;
}
Stack::~Stack()
//析构函数
{
}
void Stack::Push(T e)
//输出路径
{
cout<<"迷宫的路径为\n";
cout<<"括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向)\n";
Stack t;
//定义一个栈,按从入口到出口存取路径
int a,b;
T data;
迷宫求解c语言课程设计
迷宫求解c语言课程设计一、课程目标知识目标:1. 理解并掌握C语言中数组、函数、循环和条件语句的基本概念和应用;2. 学会设计并实现迷宫的基本结构,掌握迷宫的创建和展示方法;3. 掌握深度优先搜索(DFS)和广度优先搜索(BFS)算法在迷宫求解中的应用。
技能目标:1. 能够运用C语言编写程序,创建并展示迷宫;2. 能够运用DFS和BFS算法,实现迷宫的有效求解;3. 培养学生的编程思维,提高问题分析、程序设计和调试能力。
情感态度价值观目标:1. 培养学生对计算机编程的兴趣和热情,激发学习积极性;2. 培养学生面对问题时的耐心和毅力,增强克服困难的信心;3. 培养学生的团队合作精神,提高沟通与协作能力。
本课程针对高中年级学生,结合C语言编程知识,以迷宫求解为背景,设计具有挑战性和实用性的课程内容。
课程注重培养学生的编程技能和逻辑思维能力,同时关注情感态度价值观的引导。
通过本课程的学习,学生将能够掌握C 语言编程的基本技巧,提高解决实际问题的能力。
课程目标具体明确,便于后续教学设计和评估。
二、教学内容1. C语言基础回顾:数组、函数、循环和条件语句的基本概念及应用;相关教材章节:第二章 数组与函数、第三章 控制语句。
2. 迷宫基本结构设计:- 迷宫的表示方法:二维数组;- 迷宫的创建:随机生成、预置路径;- 迷宫的展示:打印迷宫。
相关教材章节:第四章 函数与数组、第六章 编程实例。
3. 迷宫求解算法:- 深度优先搜索(DFS)算法原理与实现;- 广度优先搜索(BFS)算法原理与实现;- 算法比较与分析。
相关教材章节:第七章 算法初步、第八章 搜索算法。
4. 程序编写与调试:- 编写C语言程序实现迷宫创建、展示和求解;- 调试技巧与优化方法;- 团队合作与分工。
相关教材章节:第九章 程序调试与优化、第十章 团队协作。
教学内容根据课程目标进行选择和组织,注重科学性和系统性。
教学大纲明确教学内容安排和进度,与教材章节紧密关联,确保学生能够扎实掌握C语言编程知识,并应用于迷宫求解问题。
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语言)
顺序栈和迷宫求解(C语⾔)顺序栈 根据《数据结构》书中的讲解,对顺序栈的⼀个基本实现。
define.h1// define.h2 #ifndef __MENGQL_DEFINE__3#define __MENGQL_DEFINE__45#define C_LOG_DBG(format, ...)6//printf("[%s@%s,%d] " format ,__FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__);7#define C_LOG_ERR(format, ...) printf("[%s@%s,%d] " format ,__FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__);8 typedef enum EStatus {ERROR, OK} Status;910#endifSqStack.h1// SqStack.h2 #ifndef __SQ_STACK_H__3#define __SQ_STACK_H__4 #include "define.h"56 typedef struct7 {8int x;9int y;10 }PosType;1112 typedef struct13 {14int ord;15 PosType seat;16int di;17 }SElemType;1819#define STACK_INIT_SIZE 10020 typedef struct21 {22 SElemType* base;23 SElemType* top;24int stacksize;25 }SqStack;2627extern Status InitStack(SqStack *S);28extern Status GetTopStack(SqStack S, SElemType *e);29extern Status PushStack(SqStack *S, SElemType e);30extern Status PopStack(SqStack *S, SElemType *e);31extern Status StackEmpty(SqStack *S);32extern Status DestoryStack(SqStack *S);33#endifSqStack.c1// SqStack.c2 #include "define.h"3 #include "SqStack.h"4 #include <stdlib.h>5 #include <stdio.h>6 Status InitStack(SqStack *S)7 {8 S->stacksize = STACK_INIT_SIZE;9 S->base = (SElemType *)malloc(S->stacksize * sizeof(SElemType));10if(S->base == NULL)11 {12 C_LOG_ERR("%s\n","MALLOC OVERFLOW");13return ERROR;14 }15 S->top = S->base;1617return OK;18 }19 Status GetTopStack(SqStack S, SElemType *e)20 {21if(S.top == S.base)22 {23 C_LOG_ERR("%s\n","STACK IS EMPTY");24return ERROR;25 }26 *e = *(S.top-1);27return OK;28 }29 Status PushStack(SqStack *S, SElemType e)30 {31if(S->top - S->base >= S->stacksize)32 {33 S->base = (SElemType *)realloc(S->base, (S->stacksize * 2) * sizeof(SElemType)); 34if(S->base == NULL)35 {36 C_LOG_ERR("%s\n","REMALLOC OVERFLOW");37return ERROR;38 }39 S->stacksize *= 2;40 }41 *(S->top++) = e;42return OK;43 }44 Status PopStack(SqStack *S, SElemType *e)45 {46if(S->top == S->base)47 {48 C_LOG_ERR("%s\n","STACK IS EMPTY");49return ERROR;50 }51 *e = *(--S->top);52return OK;53 }54 Status StackEmpty(SqStack *S)55 {56if(S->top == S->base)57 {58return OK;59 }60return ERROR;61 }62 Status DestoryStack(SqStack *S)63 {64 S->stacksize = 0;65 free(S->base);66 S->top = S->base = NULL;67return OK;68 }迷宫求解 顺序栈实现的迷宫求解是深度优先搜索,得出的路径是⾮最短路径。
用c语言实现迷宫求解完美源代码
用c语言实现迷宫求解完美源代码#include#include#include#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2#define UNDERFLOW -2typedef 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;int c;char adr[MAXLEN][MAXLEN];// 可取' ''*' '@' '#'}MazeType;// 迷宫类型Status InitMaze(MazeType&maze){// 初始化迷宫,成功返回TRUE,否则返回FALSE int m,n,i,j;printf("输入迷宫行数和列数(包括了外墙): ");scanf("%d%d",&maze.r,&maze.c); // 输入迷宫行数和列数for(i=0;i<=maze.c+1;i++){// 迷宫行外墙maze.adr[0][i]='#';maze.adr[maze.r+1][i]='#';}//forfor(i=0;i<=maze.r+1;i++){// 迷宫列外墙maze.adr[i][0]='#';maze.adr[i][maze.c+1]='#';}for(i=1;i<=maze.r;i++)for(j=1;j<=maze.c;j++)maze.adr[i][j]=' ';// 初始化迷宫printf("输入障碍的坐标((-1 -1)结束): ");scanf("%d%d",&m,&n);// 接收障碍的坐标while(m!=-1){if(m>maze.r || n>maze.c)// 越界exit(ERROR);maze.adr[m][n]='#';// 迷宫障碍用#标记printf("输入障碍的坐标((-1,-1)结束): ");scanf("%d%d",&m,&n);}//whilereturn OK;}//InitMazeStatus Pass(MazeType maze,PostType curpos){// 当前位置可同则返回TURE,否则返回FALSEif(maze.adr[curpos.r][curpos.c]==' ')// 可通return TRUE;elsereturn FALSE;}//PassStatus FootPrint(MazeType &maze,PostType curpos) {// 若走过并且可通,则返回TRUE,否则返回FALSE maze.adr[curpos.r][curpos.c]='*';//"*"表示可通return OK;}//FootPrintPostType NextPos(PostType &curpos,int i){// 指示并返回下一位置的坐标PostType cpos;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;}//NextposStatus MarkPrint(MazeType &maze,PostType curpos) {// 曾走过,但不是通路标记,并返回OKmaze.adr[curpos.r][curpos.c]='@';//"@" 表示曾走过但不通return OK;}//MarkPrintStatus MazePath(MazeType &maze,PostType start,PostType end){// 若迷宫maze存在通路,则求出一条同路放在栈中,并返回TRUE,否则返回FALSE struct LStack S;PostType curpos;int curstep;// 当前序号,1,2,3,4分别表示东南西北方向SElemType e;InitStack(S);curpos=start; //设置"当前位置"为"入口位置"curstep=1;// 探索第一位printf("以三元组形式表示迷宫路径:\n");do{if(Pass(maze,curpos)){// 当前位置可以通过FootPrint(maze,curpos);// 留下足迹e.ord=curstep;e.seat=curpos;e.di=1;printf("%d %d %d-->",e.seat.r,e.seat.c,e.di);Push(S,e);// 加入路径if(curpos.r==end.r&&curpos.c==end.c)if(!DestroyStack(S))// 销毁失败exit(OVERFLOW);elsereturn TRUE; // 到达出口else{curpos=NextPos(curpos,1);// 下一位置是当前位置的东邻curstep++;// 探索下一步}//else}//ifelse{// 当前位置不通时if(!StackEmpty(S)){Pop(S,e);while(e.di==4&& !StackEmpty(S)){MarkPrint(maze,e.seat);Pop(S,e);// 留下不能通过的标记,并退一步}//whileif(e.di < 4){e.di++;// 换一个方向探索Push(S,e);curpos=NextPos(e.seat,e.di);// 设定当前位置是该方向上的相邻printf("%d %d %d-->",e.seat.r,e.seat.c,e.di);}//if}//if}//else}while(!StackEmpty(S));if(!DestroyStack(S))// 销毁栈exit(OVERFLOW);elsereturn FALSE;}//MazePathvoid PrintMaze(MazeType &maze){// 将标记路径信息的迷宫输出到终端int i,j;printf("\n输出迷宫(*表示通路):\n\n");printf("");for(i=0;i<=maze.r+1;i++)// 打印列数名printf("%4d",i);printf("\n\n");for(i=0;i<=maze.r+1;i++){printf("%2d",i);// 打印行名for(j=0;j<=maze.c+1;j++)printf("%4c",maze.adr[i][j]);// 输出迷宫当前位置的标记printf("\n\n");}}//PrintMazeint main(){// 主函数MazeType maze;PostType start,end;char cmd;do{printf("-------创建迷宫--------\n");if(!InitMaze(maze)){printf("Initialization errors\n");exit(OVERFLOW);// 初始化失败}do{// 输入迷宫入口坐标printf("\n输入迷宫入口坐标: ");scanf("%d%d",&start.r,&start.c);if(start.r>maze.r ||start.c>maze.c){printf("\nBeyond the maze\n"); continue;}}while(start.r>maze.r ||start.c>maze.c);do{// 输入迷宫出口坐标printf("\n输入迷宫出口坐标: ");scanf("%d%d",&end.r,&end.c);if(end.r>maze.r ||end.c>maze.c){printf("\nBeyond the maze\n"); continue;}}while(end.r>maze.r ||end.c>maze.c);if(!MazePath(maze,start,end))//迷宫求解printf("\nNo path from entranceto exit!\n"); elsePrintMaze(maze);// 打印路径printf("\n需要继续创建新的迷宫吗?(y/n): "); scanf("%s",&cmd);}while(cmd=='y' || cmd=='Y');}。
基于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语⾔程序设计有所帮助。
(完整word版)迷宫(C语言版)--数据结构课程设计
一.迷宫问题求解1.问题描述迷宫问题是实验心理学的一个经典问题,心理学家把一只老鼠从一个无顶盖的大盒子的入口出赶迷宫。
迷宫中设置了很多隔壁,对前进方向形成了多出障碍,心理学家在迷宫的唯一出口处放置了一块奶酪,吸引老鼠在迷宫中寻找路径以到达出口。
然而,用计机模拟迷宫问题,即划好迷宫的隔壁的设置,让计算机从入口处进入迷宫探究出一条通路。
2.设计思路回溯法是一种不断试探且及时纠正错误的探索方法。
下面的求解过程既是使用回溯法。
从入口出发,按某一个方向向前探索,若能走通并且未走过,即某处可以到达,则到达新点,否则试探下一个方向;若所有的方向均没有通路,则沿原路返回前一个点,换下一个方向继续探索,直到找到一条通路,或无路可走又返回到入口点。
在求解过程中,为了保证在到达某一点后不能向前继续行走(无路)时,能正确返回前一个点以便继续从下一个方向向前试探,则需要用一个栈保存所有到达点的下标。
另外,求解该问题的一个重要问题是如何防止回溯时走重复节点,以避免发生死循环。
这里,我们采用对走过的结点,修改其结点信息。
如在设计之初,我们设置保存迷宫结构的二维数组中0值代表该节点可走,1值代表其不可走,那么我们可以把走过的结点值改为非0,已使其不能被再次探索。
3.数据结构设计由上面的设计思路知,若想正确的使用回溯法求解迷宫问题,必须要借助一个栈以保存走过的结点信息。
而这里我活用了栈,只把其数据结构抽象为了一个结构体数组,具体设计如下:typedef struct{}pos;pos Pos[100]; /*结构体数组以保存走过的结点信息*/4.功能函数介绍(1)判断是否找到出口函数Isover();该函数的参数是当前结点的x、y坐标与出口结点的x、y坐标,通过比较其值来判断是否找到出口结点,从而控制程序结束。
(2)对程序相关信息的简单介绍函数introduce();该函数主要是在进行绘制迷宫的图形化界面之前开发者搞的一点小插曲,以介绍跟该程序的相关的部分信息。
c语言——迷宫求解
/*人民邮电大学——迷宫求解*/#include <stdio.h>#include <stdlib.h>#define MAX 100/* 栈中最大元素个数 */#define NLENGTH 11 /*地图的第一维长度*/typedef struct{int x;/* 行下标 */int y;/* 列下标 */int d;/* 运动方向 */}DataType;struct SeqStack{ /* 顺序栈类型定义 */int t; /* 指示栈顶位置 */DataType s[MAX];};typedef struct SeqStack *PSeqStack; /* 顺序栈类型的指针类型 */ PSeqStack pastack;PSeqStack createEmptyStack_seq( void ){PSeqStack pastack;pastack = (PSeqStack)malloc(sizeof(struct SeqStack));if (pastack == NULL)printf("内存申请失败!! \n");elsepastack->t = -1;return pastack;}/*空栈吗?*/int isEmptyStack_seq( PSeqStack pastack ){return pastack->t == -1;}/*入栈操作:一个参数*/void Push_seq( PSeqStack pastack, DataType x ){if( pastack->t > MAX)printf( "堆栈溢出错误!\n" );else{pastack->t++;pastack->s[pastack->t] = x;}}/*出栈操作 */void Pop_seq( PSeqStack pastack ){if (pastack->t == -1 )printf( "堆栈溢出错误!\n" );elsepastack->t--;}/*取栈顶元素*/DataType Top_seq( PSeqStack pastack ){return (pastack->s[pastack->t]);}/*入栈操作:四个参数*/void Push_Stack(PSeqStack st, int x, int y, int d){DataType element;element.x = x;element.y = y;element.d = d;Push_seq(st, element);}/*输出路径*/void OutputPath(PSeqStack st){DataType element;printf("\n\n出迷宫的路径是:\n");while(!isEmptyStack_seq(st)){element = Top_seq(st);Pop_seq(st);printf("\n路过的节点坐标是: 第%d行第%d列 ", element.x, element.y); /* 打印路径上的每一点 */}}/*迷宫求解主函数*/void Maze_Path(int Maze[][NLENGTH], int direction[][2], int x1, int y1, int x2, int y2){int i, j, k, g, h;PSeqStack st;DataType element;st = createEmptyStack_seq( );Maze[x1][y1] = 2; /* 从入口开始进入,作标记 */Push_Stack(st, x1, y1, -1); /* 入口点进栈 */while ( !isEmptyStack_seq(st)){ /* 回退 */Pop_seq(st);element = Top_seq(st);if(isEmptyStack_seq(st)){element.x=x1;element.y=y1;element.d=-1;}i = element.x;j = element.y;for (k = element.d + 1; k <= 3; k++){ /* 依次试探每个方向 */g = i + direction[k][0];h = j + direction[k][1];if (g == x2 && h == y2 && Maze[g][h] == 0){ /* 走到出口点 */Push_Stack(st, x2, y2, -1); /* 出口点进栈 */OutputPath(st); /* 输出路径 */return;}if (Maze[g][h] == 0){ /*道路通畅,未免重复对走到没走过的点作标记 */Maze[g][h] = 2;Push_Stack(st, g, h, k); /* 进栈 */i = g; j = h; k = -1; /* 下一点转换成当前点 */}}}printf("\n未找到路径.\n");/* 栈退完未找到路径 */}/*迷宫数据*/int Maze[][11] ={1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,0,0,0,1,1,1,0,0,0,0,1,1,0,1,0,1,1,0,0,1,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,1,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1};int direction[][2]={0,1,/*x不变,Y+1*/1,0,/*X+1,Y不变*/0,-1,/*X不变,Y-1*/-1,0 /*X-1,Y不变*/}; /*向四面运动时,X,Y的增减量,即方向*/int main(){int x1,x2,y1,y2,i,j;/*入口,出口,循环变量声明*/x1 =1;y1 =1;x2 = 9;y2 = 9;for(i = 0;i<11;i++){for(j=0;j<11;j++){printf("%d ",Maze[i][j]);}printf("\n\r");}printf("从结点:第%d行,第%d列到达结点:第%d行,第%d列",x2,y2,x1,y1);Maze_Path(Maze,direction,x1,y1,x2,y2);return 0;}//QQ交流群248936001。
(完整word版)数据结构C语言迷宫求解问题(有要求和源代码)
1、迷宫求解设计一个迷宫求解程序,要求如下:✓以M × N表示长方阵表示迷宫,求出一条从入口到出口的通路,或得出没有通路的结论。
✓能任意设定的迷宫✓(选作)如果有通路,列出所有通路提示:✓以一个二维数组来表示迷宫,0和1分别表示迷宫中的通路和障碍,如下图迷宫数据为:1111111111 Array 100100010110010001011000011001101110000110001000011010001001101110110111000000011111111111入口位置:1 1出口位置:8 8✓探索过程可采用如下算法,设定当前位置的初值为入口位置;do {若当前位置可通,则{将当前位置插入栈顶;若该位置是出口位置,则结束;否则切换当前位置的东邻方块为新的当前位置;}否则,{若栈不空且栈顶位置尚有其他方向未经探索,则设定新的当前位置为沿顺时针方向旋转找到的栈顶位置的下一相邻块;若栈不空但栈顶位置的四周均不可通,则{删去栈顶位置;//从路径中删去该通道块若栈不空,则重新测试新的栈顶位置,直至找到一个可通的相邻块出栈至栈空;}}}while (栈不空);#include<stdio.h>#include<string.h>#define MaxSize 32int a[30][30];int b[30][30];int m,n;typedef struct{int i;int j;int di;}Box;typedef struct{Box data[MaxSize];int top;}StackType;bool sereach(int X,int Y,int X1,int Y1);void main(){int X,Y,Y1,X1;memset(a,0,sizeof(a));memset(b,0,sizeof(b));// for()printf("请输入迷宫的长度和宽度\n");while(~scanf("%d%d",&m,&n)){printf("请输入迷宫(0表示空地,1表示围墙)\n");for(int i=0;i<n;i++){for(int j=0;j<m;j++){scanf("%d",&a[i][j]);if(a[i][j]==1)b[i][j]=-1;}}printf("请输入迷宫起点的行号和列号\n");scanf("%d%d",&X,&Y);printf("请输入迷宫终点的行号和列号\n");scanf("%d%d",&X1,&Y1);if(!sereach(X,Y,X1,Y1))printf("该迷宫没有解!\n");printf("请输入迷宫的长度和宽度\n");}// return 0;}bool sereach(int X,int Y,int X1,int Y1){StackType st;int i,j,di,find;st.top=-1;while(a[X][Y]!=0){printf("迷宫起点的行号和列号有错,请重新输入\n");scanf("%d%d",&X,&Y);}if(a[X][Y]==0)b[X][Y]=-1;while(a[X1][Y1]!=0){printf("迷宫终点的行号和列号有错,请重新输入\n");scanf("%d%d",&X1,&Y1);}st.top++;st.data[st.top].i=X;st.data[st.top].j=Y;st.data[st.top].di=-1;do{find=0;i=st.data[st.top].i;j=st.data[st.top].j;di=st.data[st.top].di;while(di<4&&find==0){di++;switch(di){case 0:i=st.data[st.top].i-1;j=st.data[st.top].j;break;case 1:i=st.data[st.top].i;j=st.data[st.top].j+1;break;case 2:i=st.data[st.top].i+1;j=st.data[st.top].j;break;case 3:i=st.data[st.top].i;j=st.data[st.top].j-1;break;}if(b[i][j]==0&&i>=0&&i<n&&j>=0&&j<m)find=1;}if(find == 1){st.data[st.top].di=di;st.top++;st.data[st.top].i=i;s t.data[st.top].j=j;st.data[st.top].di=-1;b[i][j]=-1;find=0;}else{b[st.data[st.top].i][st.data[st.top].j]=0;st.top--;}if(i==X1&&j==Y1){printf("迷宫路径如下:\n");for(int k=0;k<=st.top;k++){printf("%d,%d\t",st.data[k].i,st.data[k].j);if((k+1)%6==0)printf("\n");}printf("\n");。
c语言实现迷宫问题
数据结构试验——迷宫问题一基本问题1.问题描述这是心理学中的一个经典问题..心理学家把一只老鼠从一个无顶盖的大盒子的入口处放入;让老鼠自行找到出口出来..迷宫中设置很多障碍阻止老鼠前行;迷宫唯一的出口处放有一块奶酪;吸引老鼠找到出口..简而言之;迷宫问题是解决从布置了许多障碍的通道中寻找出路的问题..本题设置的迷宫如图1所示..图1 迷宫示意图迷宫四周设为墙;无填充处;为可通处..设每个点有四个可通方向;分别为东、南、西、北为了清晰;以下称“上下左右”..左上角为入口..右下角为出口..迷宫有一个入口;一个出口..设计程序求解迷宫的一条通路..2.数据结构设计以一个m×n的数组mg表示迷宫;每个元素表示一个方块状态;数组元素0和1分别表示迷宫中的通路和障碍..迷宫四周为墙;对应的迷宫数组的边界元素均为1..根据题目中的数据;设置一个数组mg如下int mgM+2N+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是下一个相邻的可走的方位号}stMaxSize;// 定义栈int top=-1 //初始化栈3设计运算算法要寻找一条通过迷宫的路径;就必须进行试探性搜索;只要有路可走就前进一步;无路可进;换一个方向进行尝试;当所有方向均不可走时;则沿原路退回一步称为回溯;重新选择未走过可走的路;如此继续;直至到达出口或返回入口没有通路..在探索前进路径时;需要将搜索的踪迹记录下来;以便走不通时;可沿原路返回到前一个点换一个方向再进行新的探索..后退的尝试路径与前进路径正好相反;因此可以借用一个栈来记录前进路径..方向:每一个可通点有4个可尝试的方向;向不同的方向前进时;目的地的坐标不同..预先把4个方向上的位移存在一个数组中..如把上、右、下、左即顺时针方向依次编号为0、1、2、3.其增量数组move4如图3所示..move4x y0-110121030-1图2数组move4方位示意图如下:通路:通路上的每一个点有3个属性:一个横坐标属性i、一个列坐标属性j和一个方向属性di;表示其下一点的位置..如果约定尝试的顺序为上、右、下、左即顺时针方向;则每尝试一个方向不通时;di值增1;当d 增至4时;表示此位置一定不是通路上的点;从栈中去除..在找到出口时;栈中保存的就是一条迷宫通路..1下面介绍求解迷宫xi;yj到终点xe;ye的路径的函数:先将入口进栈其初始位置设置为—1;在栈不空时循环——取栈顶方块不退栈①若该方块为出口;输出所有的方块即为路径;其代码和相应解释如下:int mgpathint xi;int yi;int xe;int ye //求解路径为:xi;yi->xe;ye {struct{int i; //当前方块的行号int j; //当前方块的列号int di; //di是下一可走方位的方位号} stMaxSize; //定义栈int top=-1; //初始化栈指针int i;j;k;di;find;top++; //初始方块进栈sttop.i=xi;sttop.j=yi;sttop.di=-1;mg11=-1;while top>-1 //栈不空时循环{i=sttop.i;j=sttop.j;di=sttop.di; //取栈顶方块if i==xe && j==ye //找到了出口;输出路径{printf"迷宫路径如下:\n";for k=0;k<=top;k++{printf"\t%d;%d";stk.i;stk.j;if k+1%5==0 //每输出每5个方块后换一行printf"\n";}printf"\n";return1; //找到一条路径后返回1}②否则;找下一个可走的相邻方块若不存在这样的路径;说明当前的路径不可能走通;也就是恢复当前方块为0后退栈..若存在这样的方块;则其方位保存在栈顶元素中;并将这个可走的相邻方块进栈其初始位置设置为-1求迷宫回溯过程如图4所示从前一个方块找到相邻可走方块之后;再从当前方块找在、相邻可走方块;若没有这样的方快;说明当前方块不可能是从入口路径到出口路径的一个方块;则从当前方块回溯到前一个方块;继续从前一个方块找可走的方块..为了保证试探的可走的相邻方块不是已走路径上的方块;如i;j已经进栈;在试探i+1;j的下一方块时;又试探道i;j;这样会很悲剧的引起死循环;为此;在一个方块进栈后;将对应的mg数组元素的值改为-1变为不可走的相邻方块;当退栈时表示该方块没有相邻的可走方块;将其值恢复0;其算法代码和相应的解释如下:find=0;while di<4 && find==0 //找下一个可走方块{di++;switchdi{case 0:i=sttop.i-1;j=sttop.j;break;case 1:i=sttop.i;j=sttop.j+1;break;case 2:i=sttop.i+1;j=sttop.j;break;case 3:i=sttop.i;j=sttop.j-1;break;}if mgij==0 find=1;//找到下一个可走相邻方块}if find==1 //找到了下一个可走方块{sttop.di=di; //修改原栈顶元素的di值top++; //下一个可走方块进栈sttop.i=i;sttop.j=j;sttop.di=-1;mgij=-1; //避免重复走到该方块}else //没有路径可走;则退栈{mgsttop.isttop.j=0;//让该位置变为其他路径可走方块top--; //将该方块退栈}}return0; //表示没有可走路径;返回02求解主程序建立主函数调用上面的算法;将mg和st栈指针定义为全局变量void main{mgpath1;1;M;N;}3界面设计设计很简单的界面;输出路径4运行结果图5..基本运行结果二8个方向的问题1.设计思想1设置一个迷宫节点的数据结构..2建立迷宫图形..3对迷宫进行处理找出一条从入口点到出口点的路径..4输出该路径..5打印通路迷宫图..图6功能结构图当迷宫采用二维数组表示时;老鼠在迷宫任一时刻的位置可由数组的行列序号i;j来表示..而从 i;j位置出发可能进行的方向见下图7.如果i;j周围的位置均为0值;则老鼠可以选择这8个位置中的任一个作为它的下一位置..将这8个方向分别记作:E东、SE东南、S南SW西南W西、NW 西北、N北和NE东北..但是并非每一个位置都有8个相邻位置..如果i;j 位于边界上;即i=1;或i=m;或j=1;或j=n;则相邻位置可能是3个或5个为了避免检查边界条件;将数组四周围用值为1的边框包围起来;这样二维数组maze应该声明为mazem+2;n+2在迷宫行进时;可能有多个行进方向可选;我们可以规定方向搜索的次序是从东E沿顺时针方向进行..为了简化问题;规定i;j的下一步位置的坐标是x;y;并将这8个方位伤的x和y坐标的增量预先放在一个结构数组move8中见图8..该数组的每个分量有两个域dx和dy..例如要向东走;只要在j值上加上dy;就可以得到下一步位置的x;y值为i;j+dy..于是搜索方向的变化只要令方向值dir从0增至7;便可以从move数组中得到从i;j点出发搜索到的每一个相邻点x;y..x=i+movedir.dxy=j+movedir.dydx dy图7 方向位移图图8向量差图为了防止重走原路;我们规定对已经走过的位置;将原值为0改为-1;这既可以区别该位置是否已经走到过;又可以与边界值1相区别..当整个搜索过程结束后可以将所有的-1改回到0;从而恢复迷宫原样..这样计算机走迷宫的方法是:采取一步一步试探的方法..每一步都从E开始;按顺时针对8个方向进行探测;若某个方位上的mazex;y=0;表示可以通行;则走一步;若mazex;y=1;表示此方向不可通行须换方向再试..直至8个方向都试过;mazex;y均为1;说明此步已无路可走;需退回一步;在上一步的下一个方向重新开始探测..为此需要设置一个栈;用来记录所走过的位置和方向i;j;dir..当退回一步时;就从栈中退出一个元素;以便在上一个位置的下一个方向上探测;如又找到一个行进方向;则把当前位置和新的方向重新进栈;并走到新的位置..如果探测到x=m;y=n;则已经到达迷宫的出口;可以停止检测;输出存在栈中的路径;若在某一位置的8个方向上都堵塞;则退回一步;继续探测;如果已经退到迷宫的入口栈中无元素;则表示此迷宫无路径可通行..2系统算法伪代码描述:1建立迷宫节点的结构类型stack..2入迷宫图形0表示可以通1表示不可以通.. 用二维数组mazem+2n+2进行存储..数组四周用1表示墙壁;其中入口点1;1与出口点m;n固定..3函数path对迷宫进行处理;从入口开始:Whiles->top==-1&&dir>=7||x==M&&y==N&&mazexy==-1{For扫描八个可以走的方向{If找到一个可以走的方向{进入栈标志在当前点可以找到一个可以走的方向避免重复选择mazexy=-1不再对当前节点扫描}If八个方向已经被全部扫描过;无可以通的路{标志当前节点没有往前的路后退一个节点搜索}}If找到了目的地{输出路径退出循环}}未找到路径4输出从入口点到出口点的一条路径..5输出标有通路的迷宫图..3.算法流程图:图9 算法流4.程序代码:define M2 12 /M2N2为实际使用迷宫数组的大小/ define N2 11define maxlen M2 // 栈长度include <stdio.h>include<iostream.h>include <malloc.h>int M=M2-2;N=N2-2;//MN迷宫的大小typedef struct //定义栈元素的类型{int x;y;dir;}elemtype;typedef struct // 定义顺序栈{elemtype stack maxlen;int top;}sqstktp;struct moved//定义方向位移数组的元素类型对于存储坐标增量的方向位移数组move{ int dx;dy;};/////////////////////////////////////////////////////////////// /////////////////////////////////////void inimazeint mazeN2////初始化迷宫{int i;j;num;fori=0;j=0;i<=M+1;i++//设置迷宫边界mazeij=1;fori=0;j=0;j<=N+1;j++mazeij=1;fori=M+1;j=0;j<=N+1;j++mazeij=1;cout<<"原始迷宫为:"<<endl;fori=1;i<=M;i++{for j=1;j<=N;j++{num=800i+j+1500 % 327;//根据MN的值产生迷宫if num<150&&i=M||j=Nmazeij=1;elsemazeij=0;cout<<mazeij<<" ";//显示迷宫}cout<<endl;}cout<<endl;}//inimaze/////////////////////////////////////////////////////////////// ////////////////////////////////////////////////void inimovestruct moved move//初始化方向位移数组{//依次为East;Southeast;south;southwest;west;northwest;north;northeast move0.dx=0;move0.dy=1;move1.dx=1;move1.dy=1;move2.dx=1;move2.dy=0;move3.dx=1;move3.dy=-1;move4.dx=0;move4.dy=-1;move5.dx=-1;move5.dy-=1;move6.dx=-1;move6.dy=0;move7.dx=-1;move7.dy=1;}//void inistacksqstktp s /初始化栈/{s->top=-1;} /inistack/int pushsqstktps;elemtype x{ifs->top==maxlen-1returnfalse;else{s->stack++s->top=x;/栈不满;执行入栈操作/returntrue;}}/push/elemtype popsqstktp s/栈顶元素出栈/{elemtype elem;ifs->top<0 //如果栈空;返回空值{elem.x=NULL;elem.y=NULL;elem.dir=NULL;returnelem;}else{s->top--;returns->stacks->top+1; //栈不空;返回栈顶元素}} //pop/////////////////////////////////////////////////////////////// /////////////////////void pathint mazeN2;struct moved move;sqstktp s //寻找迷宫中的一条通路{int i;j;dir;x;y;f;elemtype elem;i=1;j=1;dir=0;maze11=-1; //设11为入口处do{x=i+movedir.dx;//球下一步可行的到达点的坐标y=j+movedir.dy;ifmazexy==0{elem.x=i;elem.y=j;elem.dir=dir;f=pushs;elem;//如果可行将数据入栈iff==false//如果返回假;说明栈容量不足cout<<"栈长不足";i=x;j=y;dir=0;mazexy=-1;}elseif dir < 7dir++;else{elem=pops; //8个方向都不行;回退ifelem.x=NULL{i=elem.x;j=elem.y;dir=elem.dir+1;}}}whiles->top==-1&&dir>=7||x==M&&y==N&&mazexy==-1; //循环ifs->top==-1//若是入口;则无通路cout<<"此迷宫不通";else{elem.x=x; elem.y=y; elem.dir=dir;//将出口坐标入栈f=pushs;elem;cout<<"迷宫通路是:"<<endl;i=0;while i <= s->top{cout<<""<<s->stacki.x<<";"<<s->stacki.y<<"";//显示迷宫通路ifi=s->topcout<<"-->";ifi+1%4==0cout<<endl;i++;}}}/////////////////////////////////////////////////////////////// ///////////////void drawint mazeN2;sqstktp s //在迷宫中绘制出通路{cout<<"逃逸路线为:"<<endl;int i;j;elemtype elem;fori=1;i<=M;i++ //将迷宫中全部的-1值回复为0值{forj=1;j<=N;j++{ifmazeij==-1mazeij=0;whiles->top>-1 //根据栈中元素的坐标;将通路的各个点的值改为8{elem=pops;i=elem.x;j=elem.y;mazeij=8;}fori=1;i<=M;i++{forj=1;j<=N;j++{printf"%3d";mazeij; //显示已标记通路的迷宫}cout<<endl;}}}}void main //寻找迷宫通路程序{sqstktp s;int mazeM2N2;struct moved move8;inimazemaze; //初始化迷宫数组s=sqstktp mallocsizeofsqstktp;inistacks; //初始化栈inimovemove; //初始化方向位移数组pathmaze;move;s; //寻找迷宫通路cout<<endl;drawmaze;s; //绘制作出通路标记的迷宫}5.运行结果三求所有通路和最短路径的算法1.源代码用原题的数据include <stdio.h>define M 5 /行数/define N 7 /列数/define MaxSize 100 /栈最多元素个数/int mgM+1N+1={ /一个迷宫;其四周要加上均为1的外框/ {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;} StackMaxSize;PathMaxSize; /定义栈和存放最短路径的数组/ int top=-1; /栈指针/int count=1; /路径数计数/int minlen=MaxSize; /最短路径长度/void mgpath /路径为:1;1->M-2;N-2/{int i;j;di;find;k;top++; /进栈/Stacktop.i=1;Stacktop.j=1;Stacktop.di=-1;mg11=-1; /初始结点进栈/while top>-1 /栈不空时循环/{i=Stacktop.i;j=Stacktop.j;di=Stacktop.di;if i==M-2 && j==N-2 /找到了出口;输出路径/{printf"%4d: ";count++;for k=0;k<=top;k++{printf"%d;%d ";Stackk.i;Stackk.j;if k+1%5==0 printf"\n\t"; /输出时每5个结点换一行/ }printf"\n";if top+1<minlen /比较找最短路径/{for k=0;k<=top;k++Pathk=Stackk;minlen=top+1;}mgStacktop.iStacktop.j=0; /让该位置变为其他路径可走结点/top--;i=Stacktop.i;j=Stacktop.j;di=Stacktop.di;}find=0;while di<4 && find==0 /找下一个可走结点/{ di++;switchdi{case 0:i=Stacktop.i-1;j=Stacktop.j;break;case 1:i=Stacktop.i;j=Stacktop.j+1;break;case 2:i=Stacktop.i+1;j=Stacktop.j;break;case 3:i=Stacktop.i;j=Stacktop.j-1;break;}if mgij==0 find=1;}if find==1 /找到了下一个可走结点/{ Stacktop.di=di; /修改原栈顶元素的di值/top++;Stacktop.i=i;Stacktop.j=j;Stacktop.di=-1;/下一个可走结点进栈/mgij=-1; /避免重复走到该结点/}else /没有路径可走;则退栈/{mgStacktop.iStacktop.j=0; /让该位置变为其他路径可走结点/top--;}}printf"最短路径如下:\n";printf"长度: %d\n";minlen;printf"路径: ";for k=0;k<minlen;k++{printf"%d;%d ";Pathk.i;Pathk.j;if k+1%5==0 printf"\n\t"; /输出时每5个结点换一行/ }printf"\n";}void main{printf"迷宫所有路径如下:\n";mgpath;}2求解结果6.实验收获及思考这次试验总体来说还是比较简单的;因为几个思考问题都是在基本问题的源代码上进行改进和补充..有了第一次数据结构编程和测试的经验;这次试验减少了很多困难;相对来说容易多了..附录基本问题换代码思考问题源代码在上文中已经全部给出define M 4define N 6define MaxSize 100include <stdio.h>int mgM+2N+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}};int mgpathint xi;int yi;int xe;int ye //求解路径为:xi;yi->xe;ye {struct{int i; //当前方块的行号int j; //当前方块的列号int di; //di是下一可走方位的方位号} stMaxSize; //定义栈int top=-1; //初始化栈指针int i;j;k;di;find;top++; //初始方块进栈sttop.i=xi;sttop.j=yi;sttop.di=-1;mg11=-1;while top>-1 //栈不空时循环{i=sttop.i;j=sttop.j;di=sttop.di; //取栈顶方块if i==xe && j==ye //找到了出口;输出路径{printf"迷宫路径如下:\n";for k=0;k<=top;k++{printf"\t%d;%d";stk.i;stk.j;if k+1%5==0 //每输出每5个方块后换一行printf"\n";}printf"\n";return1; //找到一条路径后返回1}find=0;while di<4 && find==0 //找下一个可走方块{di++;switchdi{case 0:i=sttop.i-1;j=sttop.j;break;case 1:i=sttop.i;j=sttop.j+1;break;case 2:i=sttop.i+1;j=sttop.j;break;case 3:i=sttop.i;j=sttop.j-1;break;}if mgij==0 find=1;//找到下一个可走相邻方块}if find==1 //找到了下一个可走方块{sttop.di=di; //修改原栈顶元素的di值top++; //下一个可走方块进栈sttop.i=i;sttop.j=j;sttop.di=-1;mgij=-1; //避免重复走到该方块}else //没有路径可走;则退栈{mgsttop.isttop.j=0;//让该位置变为其他路径可走方块top--; //将该方块退栈}}return0; //表示没有可走路径;返回0}void main{mgpath1;1;M;N;}。
迷宫求解数据结构C语言版
#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define STACK_INIT_SIZE 100 #define STACKINCREMENT 10typedef struct{int r;int c;}PosType;//通道块坐标typedef struct {int ord;//通道块在路径上的序号PosType seat;//通道块的坐标位置int di;//下一个探索的方向}SelemType;typedef struct {int r;int c;char adr[10][10];}MazeType;//迷宫行列,内容typedef struct {SelemType * base;SelemType * top;int stacksize;}SqStack;void InitStack(SqStack &S){S.base=(SelemType*)malloc(STACK_INIT_SIZE * sizeof(SelemType));if(!S.base) exit(0);S.top=S.base;S.stacksize=STACK_INIT_SIZE;}void Push(SqStack &S,SelemType &e){if((S.top-S.base)>=S.stacksize){S.base=(SelemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)* sizeof(SelemType));if(!S.base) exit(0);S.top=S.base+S.stacksize;//溢出重新定位S.stacksize+=STACKINCREMENT;}*S.top++=e;}void Pop(SqStack &S,SelemType &e){if(S.top==S.base) return;e=*--S.top;}void InitMaze(MazeType &maze){int i,j;maze.r=8;maze.c=8;for(i=0;i<10;i++){maze.adr[0][i]='#';maze.adr[9][i]='#';}for(i=0;i<10;i++){maze.adr[i][0]='#';maze.adr[i][9]='#';}for(i=1;i<9;i++)for(j=1;j<9;j++)maze.adr[i][j]='1';maze.adr[1][3]='#'; maze.adr[1][7]='#';maze.adr[2][3]='#'; maze.adr[2][7]='#';maze.adr[3][5]='#'; maze.adr[3][6]='#';maze.adr[4][2]='#'; maze.adr[4][3]='#';maze.adr[4][4]='#';maze.adr[5][4]='#';maze.adr[6][2]='#'; maze.adr[6][6]='#';maze.adr[7][2]='#'; maze.adr[7][3]='#'; maze.adr[7][4]='#'; maze.adr[7][6]='#';maze.adr[7][7]='#';maze.adr[8][1]='#';}int Pass(MazeType &maze,PosType &curpos){if(maze.adr[curpos.r][curpos.c]=='1')return 1;elsereturn 0;}void FootPrint(MazeType &maze,PosType curpos){maze.adr[curpos.r][curpos.c]='*';//已经走过的标记}PosType NextPos(PosType curpos,int i){PosType nextpos;nextpos=curpos;switch(i){case 1:nextpos.c+=1;break;case 2:nextpos.r+=1;break;case 3:nextpos.c-=1;break;case 4:nextpos.r-=1;break;default:printf("探寻方向错误!");}return nextpos;}void MarkPrint(MazeType &maze,PosType curpos){maze.adr[curpos.r][curpos.c]='@';//不通的标识}int StackEmpty(SqStack &S){if(S.base==S.top)return 1;elsereturn 0;}void MazePath(MazeType &maze,PosType start,PosType end) {SelemType e;SqStack S;InitStack(S);PosType curpos;int curstep;curpos=start;curstep=1;do{if(Pass(maze,curpos)){FootPrint(maze,curpos);//留下走过足迹*e.ord=curstep;e.seat=curpos;e.di=1;Push(S,e);//压入栈路径if(curpos.r==end.r&&curpos.c==end.c) return;curpos=NextPos(curpos,1);//探索下一步curstep++;}//ifelse{//当前位置不能通过if(!StackEmpty(S)){Pop(S,e);//top指针退后一下,指向上一步while(e.di==4&&!StackEmpty(S)){MarkPrint(maze,e.seat);//如果此步上下左右都探索过了且栈不为空留下不通过且返回一步Pop(S,e);}//while,用while是可以连续返回if(e.di<4){e.di++;Push(S,e);//换下一个方向探索curpos=NextPos(e.seat,e.di);//探索下一位置块}//if}//if}//else}while(!StackEmpty(S));}//mazepathvoid PrintMaze(MazeType &maze){int i,j;for(i=0;i<10;i++)printf("%4d",i);//输出行printf("\n\n");for(i=0;i<10;i++){printf("%2d",i);//输出列for(j=0;j<10;j++)printf("%4c",maze.adr[i][j]);printf("\n\n");}}void main(){MazeType maze;PosType start,end;InitMaze(maze);start.r=1; start.c=1;end.r=8; end.c=8;PrintMaze(maze);MazePath(maze,start,end);PrintMaze(maze);}。
迷宫求解问题解答(C语言)
迷宫求解问题解答:#include<stdio.h>#include<stdlib.h>#include<stack>#include <iostream>#define STACK_INIT_SIZE 30000#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2using namespace std;typedef int Status;char maze[20][20];typedef struct{int r;int c;}PosType;typedef struct{PosType seat;int di;}SElemType;typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;SElemType e;Status Pass(PosType pos){if(maze[pos.r][pos.c]=='0')return OK;else return ERROR;}void FootPrint(PosType pos){maze[pos.r][pos.c]='*';}void MarkPrint(PosType pos){maze[pos.r][pos.c]='@';}PosType NextPos(PosType pos,int di){PosType dire[5]={{0,0},{0,1},{1,0},{0,-1},{-1,0}};pos.r+=dire[di].r;pos.c+=dire[di].c;return pos;}stack<SElemType> s;Status MazePath(PosType start, PosType end){PosType curpos=start;do{if(Pass(curpos)){FootPrint(curpos);e.seat=curpos;e.di=1;s.push(e);if((curpos.r==end.r)&&(curpos.c==end.c))return(TRUE);curpos=NextPos(curpos,1);}else{if(!s.empty()){e=s.top();s.pop();while((e.di==4)&&(!s.empty())){MarkPrint(e.seat);e=s.top();s.pop();}if(e.di<4){e.di++;s.push(e);curpos=NextPos(e.seat,e.di);}}}}while(!s.empty());return(FALSE);}int main(){int i,j,m,n,d;PosType start,end;FILE *fp=fopen("in.txt","r");fscanf(fp,"%d%d%d%d%d%d",&m,&n,&start.r,&start.c,&end.r,&end.c); for(i=1;i<=m;i++){for(j=1;j<=n;j++){fscanf(fp,"%d",&d);maze[i][j]=d+'0';}}fclose(fp);for(i=0;i<m+1;i++){maze[i][0]='1';maze[i][n+1]='1';}for(j=0;j<=n+1;j++){maze[0][j]='1';maze[m+1][j]='1';}for(i=0;i<=m+1;i++){for(j=0;j<=n+1;j++){if(j==n+1)printf("%c\n",maze[i][j]);else printf("%c ",maze[i][j]); }}printf("\n");MazePath(start,end);{for(i=0;i<=m+1;i++){for(j=0;j<=n+1;j++){if(maze[i][j]=='1')maze[i][j]='#';if(maze[i][j]=='0')maze[i][j]=' ';printf("%c",maze[i][j]);if(j<n+1)printf(" ");}printf("\n");}}return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
else
return FALSE;
}
else
return FALSE;
}
Status MazePath(MazeType &maze,SqStack &S,PosType start,PosType end)
{
SElemType e;
PosType curpos;
InitStack(S);//curpos=start;
curpos.x=start.x;curpos.y=start.y;
//把开始位置赋给curpos;
int curstept=1;
do{
if(Pass(maze,curpos))
{
printf("\ncurpos.x=%d,curpos.y=%d\n",curpos.x,curpos.y);
time_t tm=time(0);
if(MazePath(maze,S,start,end))
Print(maze,S,r,c);
printf("求解用时大约是:%ld秒",tm-time(0));
}
void MazePrint(MazeType maze,int r,int c)
{
printf(" 0123456789");
printf("\n");
for(int i=0;i<r;++i)
{ printf("%d",i);
for(int j=0;j<c;++j)
{
for(int j=0;j<c;++j)
printf("%d",maze[i][j].data);
printf("\n");
}
}
void Print(MazeType &maze,SqStack S,int r,int c)
{
SElemType e;
//迷宫求解
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#include <time.h>//随机数生成函数的
#define OK 1
#define FALSE 0
#define OVERFLOW -1
if(!S.base) exit(OVERFLOW);
S.top=S.base+S.stacksize;
S.stacksize+=10;
}
*S.top++=e;
return OK;
}//push
Status Pop(SqStack &S,SElemType &e)
{
S.stacksize=100;
return OK;
}
Status Push(SqStack &S,SElemType e)
{
if(S.top-S.base>=S.stacksize)
{
S.base=(SElemType*)realloc(S.base,(S.stacksize+10)*sizeof(SElemType));
{
printf("\n*******\n");
printf("输入入口和出口的坐标(中间用空格隔开):");
scanf("%d %d %d %d",&x,&y,&w,&z);
start.x=x;start.y=y;end.x=w;end.y=z;
if(!Pass(maze,start))
srand((int)time(0));
int r,c;//行数和列数
printf("\n******迷宫******\n");
printf("请输入行数和列数:");
scanf("%d %d",&r,&c);
for(int i=0;i<r;++i)
for(int j=0;j<c;++j)
case 13:printf("←");break;
case 14:printf("↑");break;
}//switch
}//for
printf("\n");
}//for
}
void main()
{
MazeType maze;
SqStack S;
{
++e.direaction;
Push(S,e);
int n;n=e.direaction;
//printf("\n当前点的是(%d, %d) 方向是%d",e.seat.x,e.seat.y,e.direaction);
switch(n)
{
while(!StackEmpty(S))
{
Pop(S,e);
int n;
n=e.direaction;
switch(n)
{
case 1: maze[e.seat.x][e.seat.y].data=11;break;
case 2: maze[e.seat.x][e.seat.y].data=12;break;
case 3: maze[e.seat.x][e.seat.y].data=13;break;
case 4: maze[e.seat.x][e.seat.y].data=14;break;
}//switch
}//while
printf("\n");
for(int i=0;i<r;++i)
case 2:curpos.x=e.seat.x+1;curpos.y=e.seat.y;break;
case 3:curpos.x=e.seat.x;curpos.y=e.seat.y-1;break;
case 4:curpos.x=e.seat.x-1;curpos.y=e.seat.y;break;
}//switch
//printf("\n变相后点的是(%d, %d)",curpos.x,curpos.y);
}//if
}//if
}//else
}while(!StackEmpty(S));
{printf("\n找不到路径!"); return FALSE;}
}
{
sign=0;printf("入口是墙,请重新输入:");
}
else if(!Pass(maze,end))
{
sign=0;printf("出口是墙,请重新输入:");
}
else
{sign=1;printf("入口,出口正确。开始求解迷宫...\n");}
}while(sign==0);
while(e.direaction==4 && !StackEmpty(S))
{
maze[e.seat.x][e.seat.y].pass=0;
maze[e.seat.x][e.seat.y].nopa=1;
Pop(S,e);
}//while
if(e.direaction<4)
{
maze[i][j].data=rand()%2;
maze[i][j].pass=0;
maze[i][j].nopa=0;
}
MazePrint(maze,r,c);
PosType start,end;
int x,y,w,z;int sign=0;
do
int stacksize;
}SqStack;
Status InitStack(SqStack &S)
{
S.base=(SElemType *)malloc(sizeof(SElemType)*MAX);
if(!S.base) exit(OVERFLOW);
S.top=S.base;
e.ord=curstept;
e.seat.x=curpos.x;e.seat.y=curpos.y;
e.direaction=1;
Push(S,e);
maze[e.seat.x][e.seat.y].pass=1;
if(curpos.x==end.x && curpos.y==end.y)
if(maze[i][j].data==1)
printf("■");
else
printf("☆");
printf("\n");
}
}
void Print(MazeType maze,int r,int c)
{
for(int i=0;i<r;++i)
if(S.top==S.base) return ERROR;