C语言 迷宫问题求解（顺序栈应用示例）

最新推荐文章于 2024-05-01 20:15:53 发布
最新推荐文章于 2024-05-01 20:15:53 发布
阅读量3.3w 收藏 76
点赞数 12
分类专栏： C/C++练习 文章标签： 语言 c struct 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nuaazdh/article/details/7051278
版权 

//顺序栈的应用：迷宫
//作者：nuaazdh
//时间：2011年12月7日
#include <stdio.h>
#include <stdlib.h>

#define OK      1
#define ERROR   0
#define TRUE    1
#define FALSE   0
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

#define COLUMN 10   //迷宫行数
#define ROW 10      //迷宫列数

typedef int Status; //函数返回状态

typedef struct{//迷宫类型
    char **maze;//迷宫数据
    int **footprint;//足迹数据
    int row;//行数
    int column;//列数
}MazeType;

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;

Status InitStack(SqStack *S);
    //构造一个空栈S
Status InitMaze(MazeType *M);
    //初始化迷宫数据
Status DestroyStack(SqStack *S);
    //销毁栈S，S不再存在
Status ClearStack(SqStack *S);
    //把栈S置为空栈
Status StackEmpty(SqStack S);
    //若栈S为空栈，则返回TRUE，否则返回FALSE
int StackLength(SqStack S);
    //返回S元素的个数，即栈的长度
Status GetTop(SqStack S,SElemType *e);
    //若栈不为空，则用e返回S的栈顶元素，并返回OK；否则返回FALSE
Status Push(SqStack *S,SElemType e);
    //插入元素e为新的栈顶元素
Status Pop(SqStack *S,SElemType *e);
    //若栈S不为空，则删除S的栈顶元素，用e返回其值，并返回OK,否则返回ERROR
Status StackTraverse(const SqStack *S);
    //从栈底到栈顶依次对每个元素进行访问
Status PrintMaze(MazeType *M);
    //输出迷宫
Status MazePath(SqStack *S,MazeType maze,PosType start,PosType end);
    //若迷宫maze中存在从入口start到出口end的通道，则求得一条存放在栈中（从栈底
    //到栈顶），并返回TRUE；否则返回FALSE
Status FootPrint(MazeType *M,PosType pos);
    //将迷宫的当前位置pos设置为"走过"，即footprint该位置为1
Status Pass(MazeType *M,PosType pos);
    //判断当前位置是否走过
SElemType NewSElem(int step,PosType pos,int d);
    //创建新结点，用step，pos，d初始化该结点
PosType NextPos(PosType pos,int d);
    //将位置pos的方向设为d
Status MarkPrint(MazeType *M,PosType pos);
    //将迷宫M的pos位置，设为已走，成功返回OK；否则返回ERROR
Status PrintFoot(MazeType *M,SqStack *S);
    //输出迷宫的路径
int main()
{
    MazeType maze;//迷宫结构
    SqStack stack;//顺序栈，存储迷宫路径
    PosType start,end;//迷宫的起点和终点；
    start.x=0;start.y=1;//迷宫的起点
    end.x=8;end.y=9;//迷宫的终点
    InitMaze(&maze);//迷宫初始化
    printf("迷宫形状：\n");
    PrintMaze(&maze);//打印迷宫形状
    if(TRUE==MazePath(&stack,maze,start,end))
        printf("迷宫可解.\n");
    else
        printf("迷宫不可解.\n");
    return 0;
}

Status InitStack(SqStack *S){
    //构造一个空栈S
    S->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if(!S->base)//分配失败
    {
        printf("分配内存失败.\n");
        exit(0);
    }
    S->top=S->base;
    S->stacksize=STACK_INIT_SIZE;
    return OK;
}

Status InitMaze(MazeType *M){
    //初始化迷宫数据
    int i,j;
    char mz[ROW][COLUMN]={
    '#',' ','#','#','#','#','#','#','#','#',
    '#',' ',' ','#',' ',' ',' ','#',' ','#',
    '#',' ',' ','#',' ',' ',' ','#',' ','#',
    '#',' ',' ',' ',' ','#','#',' ',' ','#',
    '#',' ','#','#','#',' ',' ',' ',' ','#',
    '#',' ',' ',' ','#',' ','#',' ','#','#',
    '#',' ','#',' ',' ',' ','#',' ',' ','#',
    '#',' ','#','#','#',' ','#','#',' ','#',
    '#','#',' ',' ',' ',' ',' ',' ',' ',' ',
    '#','#','#','#','#','#','#','#','#','#'
    };

    M->maze=(char **)malloc(sizeof(char *)*ROW);
    M->footprint=(int **)malloc(sizeof(int *)*ROW);
    if(!M->maze||!M->footprint){
        printf("申请空间失败，迷宫无法初始化.\n");
        return ERROR;
        exit(0);
    }
    for(i=0;i<ROW;i++){
        M->maze[i]=(char *)malloc(sizeof(char)*COLUMN);
        M->footprint[i]=(int *)malloc(sizeof(int)*COLUMN);
        if(!M->maze[i]||!M->footprint[i]){
            printf("申请空间失败，迷宫初始化失败.\n");
            return ERROR;
            exit(0);
        }
    }
    for(i=0;i<ROW;i++){
        for(j=0;j<COLUMN;j++){
            M->maze[i][j]=mz[i][j];
            M->footprint[i][j]=0;
        }
    }
    M->row=ROW;//行
    M->column=COLUMN;//列
    return OK;
}

Status DestroyStack(SqStack *S){
    //销毁栈S，S不再存在
    if(!S)//S为空
    {
        printf("指针为空，释放失败.\n");
        exit(0);
    }
    free(S);
    return OK;
}

Status ClearStack(SqStack *S){
    //把栈S置为空栈
    if(!S)//S不存在
        return FALSE;
    S->top=S->base;//直接将栈顶指针指向栈底
    return OK;
}

Status StackEmpty(SqStack S){
    //若栈S为空栈，则返回TRUE，否则返回FALSE
    if(S.top==S.base)
        return TRUE;
    else
        return FALSE;
}

int StackLength(SqStack S){
    //返回S元素的个数，即栈的长度
    return S.stacksize;
}

Status GetTop(SqStack S,SElemType *e){
    //若栈不为空，则用e返回S的栈顶元素，并返回OK；否则返回FALSE
    if(S.top==S.base){
        printf("栈为空.\n");
        return FALSE;
    }else{
        *e=*(S.top-1);
        printf("栈顶元素：%c\n",*e);
        return OK;
    }
}

Status Push(SqStack *S,SElemType e){
    //插入元素e为新的栈顶元素
    if(S->top-S->base>=S->stacksize){//栈已满，追加存储空间
        S->base=(SElemType *)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(SElemType));
        if(!S->base)
        {
            printf("重新申请空间失败.\n");
            exit(0);
        }
        S->top=S->base+S->stacksize;//更改栈顶指针
        S->stacksize+=STACKINCREMENT;
    }
    *S->top++=e;
    return OK;
}

Status Pop(SqStack *S,SElemType *e){
    //若栈S不为空，则删除S的栈顶元素，用e返回其值，并返回OK,否则返回ERROR
    if(S->top==S->base){//栈为空
        printf("栈为空.\n");
        return ERROR;
    }
    *e=*(--S->top);
    return OK;
}

Status StackTraverse(const SqStack *S){
    //从栈底到栈顶依次对每个元素进行访问
    SElemType *p=S->base;
    if(S->base==S->top)
    {
        printf("栈为空.\n");
        return FALSE;
    }
    printf("栈中元素：");
    while(p!=S->top)
    {
        printf("x=%d,y=%d\n",p->seat.x,p->seat.y);
        *p++;
    }
    printf("\n");
    return OK;
}

Status PrintMaze(MazeType *M){
    //输出迷宫
    int i,j;
    for(i=0;i<M->row;i++){
        for(j=0;j<M->column;j++){
            printf("%c",M->maze[i][j]);
        }
        printf("\n");
    }
    printf("\n");
    return OK;
}

Status PrintFoot(MazeType *M,SqStack *S){
    //输出迷宫的路径
    int i,j;
    SElemType *p;
    for(i=0;i<M->row;i++){
        for(j=0;j<M->column;j++){
            M->footprint[i][j]=0;
        }
    }
    p=S->base;
    if(S->base==S->top)
    {
        printf("栈为空.\n");
        return FALSE;
    }
    while(p!=S->top)
    {
        M->footprint[p->seat.x][p->seat.y]=1;
        *p++;
    }
    for(i=0;i<M->row;i++){
        for(j=0;j<M->column;j++){
            printf("%d",M->footprint[i][j]);
        }
        printf("\n");
    }

    return OK;
}

Status MazePath(SqStack *S,MazeType maze,PosType start,PosType end){
    //若迷宫maze中存在从入口start到出口end的通道，则求得一条存放在栈中（从栈底
    //到栈顶），并返回TRUE；否则返回FALSE
    int curstep=1;//当前步数
    SElemType e;
    PosType curpos=start;//当前位置
    InitStack(S);//初始化栈
    do{
        if(TRUE==Pass(&maze,curpos)){
            FootPrint(&maze,curpos);
            e=NewSElem(curstep,curpos,1);
            Push(S,e);
            if((curpos.x==end.x)&&(curpos.y==end.y)){//到达终点（出口）
                printf("迷宫路径:\n");
                //StackTraverse(S);
                PrintFoot(&maze,S);
                return TRUE;
            }
            curpos=NextPos(curpos,1);
            curstep++;
        }//if
        else{//当前位置不能通过
            if(!StackEmpty(*S)){
                Pop(S,&e);
                while(e.di==4&&!StackEmpty(*S)){
                    MarkPrint(&maze,e.seat);
                    Pop(S,&e);
                }//while
                if(e.di<4){
                    e.di++;
                    Push(S,e);
                    curpos=NextPos(e.seat,e.di);
                }//if
            }//if
        }//else
    //PrintFoot(&maze,S);
    }while(!StackEmpty(*S));
    return FALSE;
}

Status FootPrint(MazeType *M,PosType pos){
    //将迷宫的当前位置pos设置为"走过"，即footprint该位置为1
    if((pos.x>M->row)||(pos.y>M->column))
        return FALSE;
    M->footprint[pos.x][pos.y]=1;
        return TRUE;
}

Status Pass(MazeType *M,PosType pos){
    //判断当前位置是否可通，即为走过的通道块
    if((M->row<pos.x)||(M->column<pos.y)){
        printf("位置越位.\n");
        exit(0);
    }
    if((0==M->footprint[pos.x][pos.y])&&(M->maze[pos.x][pos.y]==' '))
        return TRUE;
    else
        return FALSE;
}

SElemType NewSElem(int step,PosType pos,int d){
    //创建新结点，用step，pos，d初始化该结点
    SElemType e;
    e.ord=step;
    e.seat=pos;
    e.di=d;
    return e;
}

PosType NextPos(PosType pos,int d){
    //获取pos位置d方向的位置
    switch(d){
    case 1://东
        pos.x++;
        break;
    case 2://南
        pos.y++;
        break;
    case 3://西
        pos.x--;
        break;
    case 4://北
        pos.y--;
        break;
    default:
        printf("位置编号出错.\n");
    }
    return pos;
}

Status MarkPrint(MazeType *M,PosType pos){
    //将迷宫M的pos位置，设为已走，成功返回OK；否则返回ERROR
    if(pos.x>M->row||pos.y>M->column){
        printf("所要标记位置越位.\n");
        return ERROR;
    }
    M->footprint[pos.x][pos.y]=1;
    return OK;
}


运行结果演示：


nuaazdh
关注
  • 12
    点赞
  • 踩
  • 76
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
！-- 基于C语言的迷宫求解问题 --！
Lycorisradiata__的博客
04-21 524
迷宫求解问题    我们要先初始化一个迷宫地图，这里分为两种，一类为简单迷宫（不带环），一类为复杂迷宫（带环）。具体示例如下，这里采用6*6的数组表示迷宫地图，每个位置上对应元素的值非0即1，1表示路，0表示墙；    这里迷宫求解问题，我们可以采用两种方式求解，一种是利用函数本身递归的调用，一种则是利用循环一直查找。且这里的迷宫求解问题也分为两类，一类是简单的查找迷宫的一条路径，一类则是找到迷宫...
C语言 数据结构中求解迷宫问题实现方法
08-30
在C语言的数据结构中，解决迷宫问题是一种常见的实践，主要利用了栈或者队列的特性来进行路径搜索。本文将详细讲解如何使用...本文提供的方法是一个基础示例，帮助初学者理解迷宫问题的解决思路和C语言数据结构的应用。
用栈求解迷宫问题的所有路径及最短路径程序（纯c语言）
hooty_的博客
11-22 5566
比较关键的是怎么探查出所有的路径。 我的想法是在第一次找到出口时，在输出路径后，就直接退栈，再利用continue结束这次循环。达到回溯道路的作用。 退栈后回到上一个方块 ，换一个方向再继续试探，重复以上的过程即可。 再就是算最短路径，直接再找到出口的时候比较一下top指针就好了
迷宫问题详解
最新发布
ccc369639963的博客
05-01 1151
迷宫问题详解 迷宫问题指的是：在给定区域内，找到一条甚至所有从某个位置到另一个位置的移动路线。举个简单的例子，如图 1 所示，在白色区域内找到一条（甚至所有）从起点到终点的路线。 图 1 迷宫问题 迷宫问题就可以采用回溯算法解决，即从起点开始，采用不断“回溯”的方式逐一试探所有的移动路线，最终找到可以到达终点的路线。 回溯算法解决迷宫问题 以图 1 所示的迷宫为例，回溯算法解决此问题的具体思路是： 从当前位置开始，分别判断是否可以向 4 个方向（上、下、左、右）移动： 选择一个方向并移动到下个位置。判断此
C语言使用栈求解迷宫（以8*8迷宫为示例）
virtualxiaoman的博客
09-15 311
迷宫，栈
c语言迷宫算法入门,基于C语言实现的迷宫算法示例
weixin_39636608的博客
05-19 481
本文实例讲述了基于C语言实现的迷宫算法。分享给大家供大家参考，具体如下：利用c语言实现迷宫算法，环境是vc++6.0.#include#include#includeint visit(int,int);void setmaze();int maze[11][11]={{0,2,2},{2,0},2}};int startI,startJ; //定义入口变量int endI,endJ; //定义出...
迷宫问题输出所有路径及最短路径_C语言
weixin_73038327的博客
12-01 1234
问题描述：编写一个程序求解迷宫问题。迷宫由m行n列的二维数组设置，0表示无障碍，1表示有障碍。设入口为(1, 1)， 出口为(m, n), 每次只能从一个无障碍单元移到周围四个方向上任一无障碍单元。编程给出通过路径或无法通行的信息。基本要求:（1）输出迷宫的所有路径；（2）筛选出最短路径。
数据结构-顺序栈C++示例
SpiritedAway
09-22 546
顺序栈基本操作c++实现
请用C语言编写一个迷宫求解的程序，利用栈
weixin_42602726的博客
02-13 60
好的，我可以帮助你写一个 C 语言的迷宫求解程序。首先，你需要建立一个存储迷宫信息的二维数组，并且给出起点和终点的坐标。然后，你可以用栈来记录当前位置的坐标以及上一个位置的坐标，并用 DFS 算法来搜索迷宫的路径。 具体来说，你可以先从起点开始，将起点坐标压入栈中，然后分别尝试向上下左右四个方向移动，如果当前位置不是墙壁且没有走过，就将该位置的坐标压入栈中并标记为已经走过。如果到达了终点，则找到了...
c语言迷宫算法坐标怎么定义,基于C语言实现的迷宫算法示例
weixin_35329035的博客
05-16 127
本文实例讲述了基于C语言实现的迷宫算法。分享给大家供大家参考，具体如下：利用c语言实现迷宫算法，环境是vc++6.0.#include#include#includeint 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}...
纯c语言迷宫源码.zip
03-23
【标题】"纯c语言迷宫源码.zip" 提供的是一个使用C语言编写的迷宫求解程序的源代码，适用于计算机二级考试中的C语言学习者。这个压缩包包含了必要的代码文件和一个名为"readme.pdf"的文档，可能包含项目介绍、使用...
C语言数据结构迷宫问题
10-17
在给定的信息中，我们看到的是一个使用C语言实现的基于栈的数据结构来解决迷宫问题的示例。迷宫问题通常涉及到在一个二维网格中找到从起点到终点的有效路径，而这里的解决方案是通过广度优先搜索（BFS）或者深度优先...
纯C语言迷宫源码（附源文件和应用文件）
11-10
这个程序不仅提供了源代码，还可能包含应用示例或其他辅助文件，为学习和理解C语言编程，特别是解决算法问题提供了宝贵的实践素材。迷宫问题在计算机科学领域是一个经典的算法挑战，涉及路径查找、深度优先搜索（DFS...
c语言实现迷宫求解
10-28
此代码示例提供了一种基本的C语言实现迷宫求解的方法，但需要注意的是，实际应用中可能需要优化，例如考虑更高效的搜索算法（如BFS），或者增加递归版本的DFS来避免使用栈，以适应不同规模的迷宫。此外，还可以添加...
C语言 C语言读取十六进制文件.hex
热门推荐
思考的力量
03-17 2万+
// 读取十六进制文件（main.hex），并将其按Hex格式规定，对不同格式域进行划分 // 将划分后的格式写入main.txt文件，根据Hex格式，对响应的Flash存储单元赋值 // 将Flash存储单元写入main_formated.txt中 // 请将main.hex放在改程序的统一目录下 // 作者：nuaazdh // 时间：2012年3月16日 15:57:52 #in
C语言 稀疏矩阵操作（三元组表示法）
思考的力量
12-12 2万+
//稀疏矩阵实例 //作者：nuaazdh //时间：2011年12月11日 12:15:38 #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 typedef int Status; typedef float ElemType;
C++ 矩阵乘法
思考的力量
12-01 2万+
//构造矩阵类，重载乘法操作符 //作者：nuaazdh //时间：2011年12月1日 #include using namespace std; //Matrix矩阵类 class Matrix { public: Matrix(int mm, int nn)//构造函数 { m=mm; n=nn;
迷宫求解【栈的应用或图的应用】 c语言
05-24
迷宫求解可以使用深度优先搜索（DFS）算法来实现，也可以使用广度优先搜索（BFS）算法来实现。 这里以使用栈的应用来实现迷宫求解。具体步骤如下： 1. 定义一个结构体来表示迷宫中的一个点，包括该点的坐标和是否被访问过的状态。 ``` struct Point { int x; // 行坐标 int y; // 列坐标 int visited; // 是否被访问过 }; ``` 2. 读入迷宫的大小和迷宫地图，将其存储在一个二维数组中。 3. 定义一个栈来存储走过的路径。 4. 从起点开始，将其入栈。每次取出栈顶元素并判断是否为终点，如果是则输出路径并结束程序。如果不是，则将该点周围未走过的点入栈并标记为已访问。 5. 如果栈为空而未找到终点，则说明无解。 下面是使用栈的应用来实现迷宫求解的示例代码： ``` #include <stdio.h> #include <stdlib.h> #define MAX_SIZE 10 struct Point { int x; int y; int visited; }; struct Stack { struct Point arr[MAX_SIZE * MAX_SIZE]; int top; }; void stack_push(struct Stack *stack, struct Point point) { stack->arr[++stack->top] = point; } struct Point stack_pop(struct Stack *stack) { return stack->arr[stack->top--]; } int stack_is_empty(struct Stack *stack) { return stack->top == -1; } int main() { int n, m; // 迷宫大小 int map[MAX_SIZE][MAX_SIZE]; // 迷宫地图 struct Point start, end; // 起点和终点 struct Stack stack = { .top = -1 }; // 定义栈 // 读入迷宫大小和地图 printf("请输入迷宫大小（行数、列数）："); scanf("%d %d", &n, &m); printf("请输入迷宫地图：\n"); for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { scanf("%d", &map[i][j]); } } // 读入起点和终点 printf("请输入起点（行坐标、列坐标）："); scanf("%d %d", &start.x, &start.y); printf("请输入终点（行坐标、列坐标）："); scanf("%d %d", &end.x, &end.y); // 将起点入栈并标记为已访问 start.visited = 1; stack_push(&stack, start); // 开始搜索迷宫 while (!stack_is_empty(&stack)) { // 取出栈顶元素 struct Point cur = stack_pop(&stack); // 判断是否为终点 if (cur.x == end.x && cur.y == end.y) { // 输出路径 printf("路径：\n"); while (!stack_is_empty(&stack)) { struct Point path = stack_pop(&stack); printf("(%d,%d)\n", path.x, path.y); } printf("(%d,%d)\n", start.x, start.y); return 0; } // 将当前点周围未访问的点入栈 if (cur.x > 0 && map[cur.x-1][cur.y] == 0) { struct Point next = { cur.x-1, cur.y, 1 }; stack_push(&stack, next); map[cur.x-1][cur.y] = 1; // 标记为已访问 } if (cur.x < n-1 && map[cur.x+1][cur.y] == 0) { struct Point next = { cur.x+1, cur.y, 1 }; stack_push(&stack, next); map[cur.x+1][cur.y] = 1; // 标记为已访问 } if (cur.y > 0 && map[cur.x][cur.y-1] == 0) { struct Point next = { cur.x, cur.y-1, 1 }; stack_push(&stack, next); map[cur.x][cur.y-1] = 1; // 标记为已访问 } if (cur.y < m-1 && map[cur.x][cur.y+1] == 0) { struct Point next = { cur.x, cur.y+1, 1 }; stack_push(&stack, next); map[cur.x][cur.y+1] = 1; // 标记为已访问 } } // 如果栈为空而未找到终点，则说明无解 printf("无解！\n"); return 0; } ```
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值