C/C++利用栈实现简单迷宫问题

最新推荐文章于 2024-04-11 00:40:24 发布
最新推荐文章于 2024-04-11 00:40:24 发布
阅读量2.4k 收藏 55
点赞数 8
文章标签： 数据结构 c++ c语言 栈
本文为博主原创文章，未经博主允许不得转载。如有问题，欢迎指正。
本文链接：https://blog.csdn.net/qq_45505634/article/details/105380600
版权 
//预编译区::  
#include "stdafx.h"  
#include<iostream>  
#include<stdio.h>  
#include<stdlib.h>  
#include<string.h>  
#define MAXLEN 20       //迷宫包括外墙的最大行列数  
#define STACK_INIT_SIZE 100  
#define STACKINCREMENT 15  
#define TRUE 1  
#define FALSE 0  
#define OK 1  
#define ERROR 0  
#define OVERFLOW -2  
#define UNDERFLOW -3  
using namespace std;  
  
//数据结构定义区::  
typedef int status;  
  
//坐标位置类型  
typedef struct {  
    int r;      //迷宫中第r行  
    int c;      //迷宫中第c列  
}PosType;  
  
//栈中元素值域的类型  
typedef struct {  
    int ord;        //通道块在路径上的序号  
    PosType seat;       //通道块在迷宫上的通道位置  
    int di;     //从此通道块走向下一通道的方向  
}SElemType;  
  
//定义链式栈的存储结构  
struct LNode {  
    SElemType data;     //数据域  
    LNode *next;        //指针域  
};  
  
typedef struct LStack {  
    LNode *top;     //栈顶指针  
    LNode *base;        //栈底指针  
    int stacksize;      //栈的大小  
}SqStack;  
  
//迷宫类型(需要打印呈现)  
typedef struct {  
    int r;  
    int c;  
    char addr[MAXLEN][MAXLEN];      //表示通道的矩阵  
}MazeType;  
  
//函数声明区::  
void InitStack(LStack &s);  
status StackEmpty(LStack s);  
void PushStack(LStack &s, SElemType e);  
void Pop(LStack &s, SElemType &e);  
status DestroyStack(LStack &s);  
void OverturnStack(SqStack S, SqStack &T);  
void InitMaze(MazeType &maze);  
status CreatMaze(MazeType &maze, PosType &start, PosType &end);  
status WhetherPass(MazeType &maze, PosType curpos);  
void FootPrint(MazeType &maze, PosType curpos);  
PosType NextPos(PosType &curpos, int i);  
void MarkPrint(MazeType &maze, PosType curpos);  
status MazePath(MazeType &maze, PosType start, PosType end, SqStack &S);  
void PrintMaze(MazeType &maze, PosType start, PosType end);  
void PrintStack(SqStack S);  
  
//主函数  
int main(void) {  
    SqStack S, T;  
    InitStack(S); InitStack(T);  
    MazeType maze;  
    PosType start, end;  
    InitMaze(maze);  
    start.c = start.r = 0; end.c = end.r = 0;  
    printf("----------------创建迷宫开始----------------\n");  
    if (!CreatMaze(maze, start, end)) {  
        printf("初始化失败!!!\n");  
        exit(OVERFLOW);  
    }  
    printf("----------------创建迷宫结束----------------\n");  
    printf("\n");  
    printf("----------------原始迷宫模型图----------------\n");  
    PrintMaze(maze, start, end);  
    printf("\n");  
    printf("----------------走出迷宫的路径----------------\n");  
    if (!MazePath(maze, start, end, S))     //当栈被销毁的时候，则没有一条通路  
        printf("没有一条通路!!!\n");      //否则打印输出栈中的元素  
    else {  
        OverturnStack(S, T); PrintStack(T); DestroyStack(S);  
    }  
    printf("----------------迷宫路径模型图(o代表一条通路)----------------\n");  
    PrintMaze(maze, start, end);  
    system("pause");  
    return 0;  
}  
  
//---------栈的算法开始------------  
//构造一个空栈  
void InitStack(LStack &s) {  
    s.base = (LNode*)malloc(STACK_INIT_SIZE*sizeof(LNode));     //为指针p分配空间  
    if (!s.base) {  
        printf("分配失败，退出程序!");  
        exit(OVERFLOW);  
    }  
    s.top=s.base;       //将栈底和栈顶指针指向p指向的位置        
    s.base->next = NULL;     //栈顶指针的指针域置空  
    s.stacksize = STACK_INIT_SIZE;  
    return;  
}  
  
//若栈s为空栈，则返回true，否则返回false  
status StackEmpty(LStack s) {  
    if (s.top == s.base) return TRUE;       //若栈顶指针与栈底指针重合，则是空栈  
    else return FALSE;  
}  
  
//插入元素e成为新的栈顶元素  
void PushStack(LStack &s, SElemType e) {  
    if (s.top - s.base >= s.stacksize) {  
        s.base = (LNode*)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(LNode));  
        if (!s.base) exit(OVERFLOW);  
        s.top = s.base + s.stacksize;  
        s.stacksize += STACKINCREMENT;  
    }  
    (*s.top).data= e;  
    s.top++;  
    return;  
}  
  
//删除s的栈顶元素，并用e返回其值  
void Pop(LStack &s, SElemType &e) {  
    if (s.top == s.base) exit(ERROR);       //如果为空栈，退出  
    s.top--;  
    e = (*s.top).data;  
    return;  
}  
  
//栈s的销毁  
status DestroyStack(LStack &s) {  
    free(s.base);  
    s.base= NULL;  
    s.top=NULL;  
    s.stacksize = 0;  
    return OK;  
}  
  
//将栈S中的所有元素翻转致栈T:用于对于路径的输出，由于栈不能直接访问栈底指针，所以需要翻转  
void OverturnStack(SqStack S,SqStack &T){  
    SElemType e;  
    do{  
        Pop(S, e); PushStack(T, e);  
    } while (S.base != S.top);  
    return;  
}  
//---------栈的算法结束------------  
  
//---------迷宫实现开始------------  
//初始化迷宫  
void InitMaze(MazeType &maze){  
    maze.c = 0;  
    maze.r = 0;  
    return;  
}  
  
//创建迷宫  
status CreatMaze(MazeType &maze, PosType &start,PosType &end) {  
    int i, j, m=0, n=0;  
    printf("请输入迷宫的行数和列数(包含外墙):");  
    scanf_s("%d,%d", &maze.r, &maze.c);  
    for (i = 0; i < maze.c; i++) {  
        maze.addr[0][i] = '#';      //给出上下围墙  
        maze.addr[maze.r -1][i] = '#';  
    }  
    for (i = 1; i < maze.r-1; i++) {  
        maze.addr[i][0] = '#';      //给出左右围墙  
        maze.addr[i][maze.c - 1] = '#';  
    }  
    for (i = 1; i < maze.r-1; i++) {  
        for (j = 1; j < maze.c-1; j++) {  
            maze.addr[i][j] = ' ';      //将围墙内的通道块赋空值  
        }  
    }  
    printf_s("\n请输入迷宫入口：");  
    do {  
        scanf_s("%d,%d", &start.r, &start.c);  
        if (start.r == 0 || start.r >= maze.r || start.c >= maze.c) {     //超出迷宫界限的时候跳出本次循环，继续循环输入入口  
            printf("上一入口超出迷宫界限，请重新输入入口坐标!\n");      //入口不能设置在四角和上下两个边界上  
            continue;  
        }  
        else break;  
    } while (start.r == 0 || start.r >= maze.r || start.c >= maze.c);  
    printf("\n");  
    printf_s("请输入迷宫出口：");  
    do {  
        scanf_s("%d,%d", &end.r, &end.c);  
        if (end.r == 0 || end.c == 0 || end.r >= maze.r || end.c >= maze.c) {     //超出迷宫界限的时候跳出本次循环，继续循环输入入口  
            printf_s("上一出口超出迷宫界限，请重新输入出口坐标!\n");  
            continue;  
        }  
        else break;  
    } while (end.r == 0 || end.c == 0 || end.r >= maze.r || end.c >= maze.c);  
    maze.addr[start.r][start.c] = ' ';  
    maze.addr[end.r][end.c] = ' ';  
    printf("\n请输入障碍物的坐标(x,y)(以x,y=-1结束):\n");  
    while (m != -1) {  
        scanf_s("%d,%d", &m, &n);       //系统坐标原点默认为(0,0)  
        if (m == 0 || n== 0 || m >= maze.r || n > maze.c) {  
            printf("上一坐标输入错误，系统自动舍弃，请重新输入坐标!\n");   
            m = 0; n = 0; continue;  
        }  
        else if (m == -1 && n == -1) continue;  
        else maze.addr[m][n] = '#';  
    }  
    return OK;  
}  
  
//判断当前位置可否通过，可通过返回true  
status WhetherPass(MazeType &maze, PosType curpos) {  
    if (maze.addr[curpos.r][curpos.c] == ' ') return TRUE;  
    else return FALSE;  
}  
  
//若该通道块走过并且可通，就记录下来  
void FootPrint(MazeType &maze, PosType curpos) {  
    maze.addr[curpos.r][curpos.c] = 'o';  
    return;  
}  
  
//指示并返回下一位置的坐标  
PosType NextPos(PosType &curpos, int i) {  
    switch (i) {        //向各个方向前进一个单位，并返回位置值  
    case 1:curpos.c += 1; break;        //向东前进一个单位  
    case 2:curpos.r += 1; break;        //向南前进一个单位  
    case 3:curpos.c -= 1; break;        //向西前进一个单位  
    case 4:curpos.r -= 1; break;        //向北前进一个单位  
    default:exit(ERROR);  
    }  
    return curpos;  
}  
  
//曾经走过，但不是通路，就标记  
void MarkPrint(MazeType &maze, PosType curpos) {  
    maze.addr[curpos.r][curpos.c] = '@';  
    return;  
}  
  
//若迷宫存在一条通路，则求出一条通路存放到栈中  
status MazePath(MazeType &maze, PosType start, PosType end ,SqStack &S){  
    PosType curpos;     //记录当前元素位置  
    int curstep = 1,flag=0; //记录能通行的通道块在栈中的路径顺序  
    SElemType e;        //记录可压住栈中的当前通道块的信息  
    curpos = start;  
    printf("用抽象数据类型三元组【(x,y)方向】表示迷宫路径:\n");  
    do {  
        if (WhetherPass(maze, curpos)) {        //如果该路径块可通行  
            FootPrint(maze, curpos);        //记录下通行过的痕迹  
            e.ord = curstep;        //将栈中的顺序给e的ord属性  
            e.seat = curpos;        //将该通道块的位置给e的curpos属性  
            e.di = 1;       //将初始方向设为向东(1)  
            PushStack(S, e);        //将该可通的通道块压入栈  
            if (curpos.r == end.r&&curpos.c == end.c) {     //如果遇到了出口则退出  
                return TRUE;  
            }  
            else {      //如果没有遇到出口  
                curpos = NextPos(curpos, 1);        //那么寻找下一个位置  
                curstep++;      //计数器加1  
            }  
        }  
        else {      //如果该路径块不通  
            if (!StackEmpty(S)) {       //如果栈不为空  
                Pop(S, e);      //将栈顶元素出栈也就是退回上一个元素，将e返回出来判断是否再次进行方向的改变，也就是将栈顶元素进行悬挂操作  
                while (e.di == 4 && !StackEmpty(S)) {       //当四个方向都不通并且栈b不为空时  
                    MarkPrint(maze, e.seat);        //记录该通道块不通  
                    Pop(S, e);  
                    //将栈顶元素出栈也就是退回上一个位置  
                }  
                if (e.di < 4) {      //当四个方向没有尝试完时  
                    e.di++;     //换一个方向  
                    PushStack(S, e);        //将换方向之后的位置压栈  
                    curpos = NextPos(e.seat, e.di);     //当前位置下移  
                }  
            }  
        }  
    } while (!StackEmpty(S));  
    return FALSE;  
}  
  
//将标记路径信息输出到终端显示屏  
void PrintMaze(MazeType &maze,PosType start, PosType end) {  
    int i, j;  
    printf("          ");       //10个空格  
    for (i = 0; i <maze.c ; i++) printf("%2d", i);  
    printf("\n");  
    for (i = 0; i < maze.r; i++) {  
        if (i == start.r-1) printf("entrance%2d", start.r - 1);  
        else if (i == start.r)  printf("      ->%2d", start.r);  
        else printf("%10d", i);  
        for (j = 0; j < maze.c; j++) {  
            printf("%2c", maze.addr[i][j]);  
            if (i == end.r - 1 && j == end.c) printf(" exit");  
            else if (i == end.r&&j == end.c) printf("<-");  
        }  
        printf("\n");  
    }  
    return;  
}  
  
//输出栈中的路径  
void PrintStack(SqStack S){  
    int flag=0;  
    printf("迷宫中的一条通路如下:\n");  
    do{  
        S.top--;        //将栈顶指针指向想要输出的栈顶元素  
        if ( flag % 5 == 0) printf("\n");  
        switch (S.top->data.di) {  
        case 1:  
            printf("(%d,%d)向东->",S.top->data.seat.r, S.top->data.seat.c);  
            flag++; break;  
        case 2:  
            printf("(%d,%d)向南->", S.top->data.seat.r, S.top->data.seat.c);  
            flag++; break;  
        case 3:  
            printf("(%d,%d)向西->", S.top->data.seat.r, S.top->data.seat.c);  
            flag++; break;  
        case 4:  
            printf("(%d,%d)向北->", S.top->data.seat.r, S.top->data.seat.c);  
            flag++; break;  
        }  
    } while (S.base != S.top);  
    printf("结束\n");  
    return;  
}

 

学IT的星同学
关注
  • 8
    点赞
  • 踩
  • 55
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
迷宫问题（C++）： 最短路径计算（队列）&& 路径输出（栈）（附一个易错点~）
H13420972436的博客
04-07 521
回溯路径的原理：从出口开始，在re_bd（PS: re_bd[ i ][ j ]用来记忆从起点到第 i 行第 j 列的最短路径长度）里找周围八个方向中路径长度少1的点， 故一般情况可用以下代码非注释部分来判断。~都看到这啦， 你一定是个超级认真的友友，关注一下吧~ 😋ღ ʕ̡̢̡•̫͡•ʔ̢̡̢ ღ😋。”， 在re_bd == 1 时就结束寻找，在printf栈元素之前先print一下起点坐标。1.补充上面被注释掉的“if(org == 0) // 如果是起点”部分， 将起点。在于最短路径的回溯过程。
运用栈求解迷宫问题C/C++
热门推荐
g15827636417的博客
10-07 2万+
用栈解决基本的迷宫问题C/C++ 1、问题描述：设置迷宫为m*n的二维数组，起点坐标为（1，1），中点坐标为（m，n），0为通路，1为死路，为防止数组越界将四周设置边界1，即数组变为（m+2）*（n+2）数组，迷宫如下....      迷宫 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 1 1 1
C++迷宫问题完全详解
weixin_42163707的博客
12-20 2256
深度优先搜索（DFS）和广度优先搜索（BFS）是两种常用的图遍历算法，适用于不同的问题和场景。广度优先使用的是Queue队列，队列是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口。这里使用了栈，stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口。迷宫我们都玩过，有些复杂的看的眼花缭乱，但是有没有想过，让机器帮你完成这个工作，想着就很酷，好，在实际应用中，根据问题的特点和需求，选择合适的算法来进行图遍历是非常重要的。
数据结构——迷宫问题（顺序栈、C++）
m0_53468233的博客
08-01 9523
顺序栈求解随机生成迷宫的通路（C++)
C++数据结构学习笔记（一）栈的应用——迷宫问题
Vanderbiol的博客
04-29 970
有一个 m×n 格的迷宫(表示有 m 行、n 列)，其中有可走的也有不可走的，如果用 0 表示可以走，1表示不可以走，起始点（1，1）、结束点（8，8）（起始点和结束点都是用两个数据来描述的，分别表示这个点的行号和列号）。现在要你编程找出所有可行的道路，要求所走的路中没有重复的点，走时只能是上下左右四个方向。如果一条路都不可行，则输出相应信息。
【栈】实现迷宫求解(C++)(详解)
半生瓜のblog
10-15 6215
迷宫求解 从入口进入开始， 向不同方向试探，走到死胡同就退回。 找迷宫通路需要使用回溯法，找迷宫通路是对回溯法的一个很好的应用，实现回溯的过程用到数据结构—栈！ 回溯法： ​ 对一个包括有很多个结点，每个结点有若干个搜索分支的问题，把原问题分解为若干个子问题求解的 算法；当搜索到某个结点发现无法再继续搜索下去时，就让搜索过程回溯(回退)到该节点的前一个结点，继续 搜索该节点外的其他尚未搜索的分支；如果发现该结点无法再搜索下去，就让搜索过程回溯到这个结点的前一 结点继续这样的搜索过程；这样的搜索过程一
migong.zip_C/C++_
08-10
在C/C++编程中，这通常需要利用算法、数据结构以及传感器输入来实现路径规划和决策。可能包含以下几个关键知识点： 1. **基础编程概念**：C/C++的基础语法，包括变量、控制流（如if-else、循环）、函数等。 2. **...
C.rar_数据结构_C/C++_
08-11
通过阅读这份文档，我们可以获取更多关于如何构建和解决迷宫问题的信息，包括可能的数据结构实现、搜索算法的细节以及如何利用C/C++的特性来优化代码性能。 总之，这个项目涵盖了数据结构中的核心概念，如链表、栈...
c++ 栈 解决迷宫问题
03-20
通过阅读和分析这段代码，读者可以深入了解如何利用栈数据结构解决实际问题，增强对C++编程和算法的理解。 总之，迷宫问题的解决是一个典型的编程挑战，而使用栈则是一种高效且直观的方法。通过C++实现，我们可以...
Maze-problem.rar_数据结构_C/C++_
08-12
在这个C/C++项目中，我们探讨如何利用这些理论来解决实际的迷宫问题。TUEBOC是一个在线编译器，使得我们可以在云端直接运行和测试代码，极大地提高了开发和学习的便利性。 首先，我们需要理解迷宫问题的基本设定。...
迷宫问题.docx(C/C++)-期末实验报告/课程设计
12-29
《迷宫问题——C/C++实现与数据结构分析》 迷宫问题是一个经典的计算机科学问题，它涉及到数据结构的设计和算法的应用。在这个问题中，我们需要设计一种数据结构来表示迷宫，然后找到从入口到出口的路径。以下是...
C++ 数据结构求解迷宫问题（栈）
qq_63289396的博客
03-27 1274
求得的通路以三元组（i,j,d）的形式输出，其中：（i,j）指示迷宫中的一个坐标，d表示走到下一坐标的方向，如：对于下列数据的迷宫，输出的一条通路为：（1，1，1），（1,2,2）,(3,2,3),(3,1,2),…我们可以依次从栈中取出路径上的点坐标和方向信息，并输出为三元组的形式（i，j，d），表示每一步的位置和方向。以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。可以使用一个栈来辅助搜索迷宫的路径。
使用栈求解迷宫问题C++
ding_programmer的博客
11-21 4470
使用栈求解迷宫问题 C++ 题目：以一个 m*n 的长方阵表示迷宫，0 和 1 分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 迷宫根据一个迷宫数据文件建立。迷宫数据文件由一个包含 0、1 的矩阵组成。迷宫的通路可以使用通路上各点的坐标序列进行展示(使用图形展示最佳)。 栈类的定义： //这里使用的是链表描述栈类,可直b接使用STL里...
敲线性表代码时遇到的问题（C++)【exit,return】
jikenvhai的博客
04-28 1389
1：exit(OVERFLOW) ①exit简介 为C++的退出函数，声明于stdlib.h中，对于C++其标准的头文件为cstdlib,声明为 void exit(int value); exit(0)：运行正常退出程序 exit(1)：运行异常退出退出程序，返回值1是返回给操作系统的 exit(x)（x不为0）：都表示异常退出 exit的功能为，退出当前运行的程序，并将参数value返回给主调进程。 OVERFLOW为math.h中的一个宏定义，其值为3。含义为运算过程中出现了上溢，即运算结果
数据结构之迷宫问题求解(一)利用栈与递归求解出口
weixin_30567225的博客
12-03 382
　　本文适合于对迷宫问题已有初步研究,或阅读代码能力较强的人. 　　因此,如果你对迷宫问题一无所知,请参考其他更详细的资料. 　　迷宫问题,是一个对栈(Stack)典型应用的例子之一. 　　假如,有如下10X10的迷宫(0代表通路,1代表障碍),我们需要用写程序来找出迷宫的出口. 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 1 0 0 0 0 1 0 0...
数据结构课程设计2：迷宫问题
Joanna0523的博客
01-13 2212
利用栈操作实现迷宫问题求解。
数据结构课程设计（二）---迷宫问题（必做）（栈与队列）
最新发布
c55555556的博客
04-11 613
在主函数中，程序首先读取文件中的迷宫信息，然后让用户输入起点和终点坐标，并进行DFS搜索，最后输出找到的路径或者提示无解。这段代码实现了一个迷宫求解的功能，使用了DFS深度优先搜索算法以及回溯法的思想来查找从起点到终点的路径。来控制字体颜色，若是找到可以连通的路径，则以绿色输出路径；若是不能找到，则以红色输出:“搜索完毕，此迷宫无解！函数）等实现栈的基础功能，同时还实现了打印栈（在结果显示方面，为了实现良好交互的界面，通过。Node* base;// 节点数据结构，存储节点。// 栈数据结构，存储栈。
数据结构之迷宫求解栈（链式栈）实现，队列（循环队列）实现
qq_43312665的博客
01-01 605
思路： 将迷宫的布局的矩阵（对应位置的值为0：表示通路，1：表示障碍，-1：表示已访问过）作为全局变量，flag作为全局变量，flag=1:邻居中有出口，flag=0：邻居中无出口，然后先把入口Enter的位置入栈，然后把入口在迷宫布局中对应的值改成-1，表示已经访问过，然后进入循环，{栈顶元素出栈，先判断栈顶元素是否是出口的位置，如果是，则退出循环，如果不是则继续，将flag改成0，然后从出栈元...
迷宫问题——堆栈应用（C++版）
06-11 872
1.设计一个坐标类： class mazepoint { friend class mazestack; public: mazepoint(){} mazepoint(int a, int b) { x = a; y = b; } ~mazepoint(){} private: int x; int y; mazepoint* next; }; 2.设计一个堆栈，存

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值