栈的应用-迷宫解题

最新推荐文章于 2021-05-29 16:09:42 发布
最新推荐文章于 2021-05-29 16:09:42 发布
阅读量757 收藏
点赞数
分类专栏： 算法学习 文章标签： 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuerenlv123/article/details/26358245
版权

总结：这个是网上找的，下面一个是我在他基础上修改的。

/* 
二. 栈的应用-迷宫解题 
*/  
#include<stdio.h>  
#include<malloc.h>  
#include<stdlib.h>  
  
#define TRUE  1   
#define FALSE 0  
#define OK    1  
#define ERROR 0  
#define INFEASIBLE -1  
#define OVERFLOW   -2  
  
//坐标类型  
typedef struct  
{  
    int x;          
    int y;          
}Postype;           

//栈的元素类型  
typedef struct  
{  
    int x;  
    int y;          
}ElemType;          
  
//二维数组，存储迷宫
int MAP[9][9] =    
{      
     0,0,0,0,0,0,0,0,0,  
     0,1,0,0,1,1,1,1,0,  
     0,1,0,0,1,1,1,1,0,  
     0,1,1,1,1,0,1,1,0,  
     0,1,0,1,0,1,1,1,0,  
     0,1,0,1,0,1,1,1,0,  
     0,1,0,1,0,1,1,1,0,  
     0,0,0,1,1,1,1,1,0,  
     0,0,0,0,0,0,0,0,0,    
};  

/*-------------------------------------栈的元素类型定义完毕-------------------------*/  
typedef int Status;     //函数返回值  
  
#define STACK_INIT_SIZE 5     // 栈的初始大小  
#define STACK_INCREMENT 10      // 每次增加的空间大小  
  
  
//下面给出栈的相关定义  
typedef struct  
{  
    ElemType *base;     //在构造栈之前和销毁之后，base的值为NULL  
    ElemType *top;      //栈顶指针  
    int stacksize;      //当前已分配的存储空间，以元素为单位  
}ZJC_Stack;  
  
//--------------------------------------栈基本操作的算法部分--------------------------   
//栈的初始化  
Status InitStack(ZJC_Stack &S)    
{  
       
    S.base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));    //分配内存空间  
	if(!S.base){            
        exit(OVERFLOW);  
	}
    else                //否则分配成功  
    {  
        S.top = S.base;    
        S.stacksize  = STACK_INIT_SIZE;    
        return  OK;  
    }  
  
}  

//获得栈顶元素  
ElemType GetTop(ZJC_Stack S)  
{      
    if(S.top == S.base )	
        exit(ERROR);       
    return *(S.top - 1);       
}  
//压栈  
Status Push(ZJC_Stack &S,ElemType e)  
{                      
    if(S.top - S.base >= S.stacksize)       
    {  
        S.base = (ElemType*)realloc(S.base,(S.stacksize + STACK_INCREMENT) * sizeof(ElemType));  
        if(!S.base)  
            exit(OVERFLOW);  
		S.top = S.base + S.stacksize; 
        S.stacksize += STACK_INCREMENT;        
               
    }  
    *S.top++ = e;  
    return OK;  
}  
void Print_Path(ZJC_Stack S)    //打印出栈中的元素  
{  
    printf("\n寻路完成..路径坐标值如下：......\n");  
    ElemType *p = S.base;       //首先p指向栈底指针  
    ElemType temp;     
    while( p != S.top)          //只要没有到顶端，指针就移动，然后输出元素值  
    {  
        temp = *p;  
        printf("\n路径 x = %d , y = %d",temp.x,temp.y);  
        p++;          
    }  
}  
  
//出栈函数  
Status Pop(ZJC_Stack &S,ElemType &e)  
{  
    if(S.top == S.base      )   //空栈，返回错误  
		return ERROR;  
    else                        //不是空栈  
    {         
        e = * --S.top;  
        return OK;  
    }  
}  
void PathAddToStack(int i,int j,ElemType temp,ZJC_Stack &robot)     //因为要修改值，所以取地址，开始没加取地址符号，栈顶元素一直是(1,1)  
{  
    temp.x = i,temp.y = j;  
    Push(robot,temp);  
    MAP[i][j] = 2;                      //标记已经走过该格子了,当初想是否需要用其他标记，实际上不需要的，既然标记2，那么证明当然可以走过(不是墙)!  
}  
void MAZH_SOLVE(int endx,int endy)      //解决迷宫问题函数,参数为终点的坐标  
{                             
    int i = 1,j = 1;                    //起点坐标    
    ZJC_Stack robot;                    //定义栈；  
    if(InitStack( robot ) )             //初始化栈  
        printf("\n栈的初始化完成....\n");                                        
    ElemType CurrentPos ;               //当前位置         
    ElemType start;                     //初始位置的相关信息  
    ElemType temp;                      //暂时用的  
    start.x = i;  
    start.y = j;  
    temp = start;  
    
    MAP[i][j] = 2;                      //走过的标记为2             
    Push(robot,start);                  //初始位置入栈  

    printf("\n开始寻路....\n");   
    do                                  //主要寻路算法：  
    {  
          
          CurrentPos = GetTop(robot);  
          i = CurrentPos.x;  
          j = CurrentPos.y;  
          printf(" \n寻路过程如下栈顶元素的 x = %d ,y = %d....\n",i,j);  
          if(MAP[i][j+1] == 1)          //表明向下一格走得通  
          {                                       
              printf("\n向下能走动");    //向下前进一步，压栈，标记  
              j++;  
              PathAddToStack(i,j,temp,robot);                             
          }  
          else if( MAP[i + 1][j] == 1)         
          {  
               printf("\n向右能走动");  
                i++;                           
                PathAddToStack(i,j,temp,robot);  
          }  
          else  if(MAP[i - 1][j] == 1)          
          {  
               printf("\n向左能走动");  
                i--;                           
                PathAddToStack(i,j,temp,robot);  
          }  
          else if(MAP[i][j - 1] == 1)          
          {  
               printf("\n向上能走动");  
                j--;                           
                PathAddToStack(i,j,temp,robot);  
          }  
          else  //都走不动  
          {  
               printf("\n都走不动，退栈");                           
               Pop(robot,temp);  
          }  
      
    }while( GetTop(robot).x != endx || GetTop(robot).y != endy);        //只要栈顶元素的x,y不等于终点坐标的x,y,则一直循环找路径  
    printf("\n完成!\n");  

    Print_Path(robot);                  //打印出坐标值                               
}  



int main()    //入口函数  
{      
    MAZH_SOLVE(7,7);       
    return 0;  
}  
  




/* 
二. 栈的应用-迷宫解题 
*/  
#include<stdio.h>  
#include<malloc.h>  
#include<stdlib.h>  
  
#define TRUE  1   
#define FALSE 0  
#define OK    1  
#define ERROR 0  
#define INFEASIBLE -1  
#define OVERFLOW   -2  
  
//坐标类型  
typedef struct  
{  
    int x;          
    int y;          
}Postype;           

//栈的元素类型  
typedef struct  
{  
    int x;  
    int y;          
}ElemType;          
  
//二维数组，存储迷宫
int MAP[7][7] =    
{      
     
     1,0,0,1,1,1,1,  
     1,0,0,1,1,1,1,  
     1,1,1,1,0,1,1,  
     1,0,1,0,1,1,1,  
     1,0,1,0,1,1,1,  
     1,0,1,0,1,1,1,  
     0,0,1,1,1,1,1,
    
};  

/*-------------------------------------栈的元素类型定义完毕-------------------------*/  
typedef int Status;     //函数返回值  
  
#define STACK_INIT_SIZE 5     // 栈的初始大小  
#define STACK_INCREMENT 10      // 每次增加的空间大小  
  
  
//下面给出栈的相关定义  
typedef struct  
{  
    ElemType *base;     //在构造栈之前和销毁之后，base的值为NULL  
    ElemType *top;      //栈顶指针  
    int stacksize;      //当前已分配的存储空间，以元素为单位  
}ZJC_Stack;  
  
//--------------------------------------栈基本操作的算法部分--------------------------   
//栈的初始化  
Status InitStack(ZJC_Stack &S)    
{  
       
    S.base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));    //分配内存空间  
	if(!S.base){            
        exit(OVERFLOW);  
	}
    else                //否则分配成功  
    {  
        S.top = S.base;    
        S.stacksize  = STACK_INIT_SIZE;    
        return  OK;  
    }  
  
}  

//获得栈顶元素  
ElemType GetTop(ZJC_Stack S)  
{      
    if(S.top == S.base )	
        exit(ERROR);       
    return *(S.top - 1);       
}  
//压栈  
Status Push(ZJC_Stack &S,ElemType e)  
{                      
    if(S.top - S.base >= S.stacksize)       
    {  
        S.base = (ElemType*)realloc(S.base,(S.stacksize + STACK_INCREMENT) * sizeof(ElemType));  
        if(!S.base)  
            exit(OVERFLOW);  
		S.top = S.base + S.stacksize; 
        S.stacksize += STACK_INCREMENT;        
               
    }  
    *S.top++ = e;  
    return OK;  
}  
void Print_Path(ZJC_Stack S)    //打印出栈中的元素  
{  
    printf("\n寻路完成..路径坐标值如下：......\n");  
    ElemType *p = S.base;       //首先p指向栈底指针  
    ElemType temp;     
    while( p != S.top)          //只要没有到顶端，指针就移动，然后输出元素值  
    {  
        temp = *p;  
        printf("\n路径 x = %d , y = %d",temp.x,temp.y);  
        p++;          
    }  
}  
  
//出栈函数  
Status Pop(ZJC_Stack &S,ElemType &e)  
{  
    if(S.top == S.base      )   //空栈，返回错误  
		return ERROR;  
    else                        //不是空栈  
    {         
        e = * --S.top;  
        return OK;  
    }  
}  
void PathAddToStack(int i,int j,ElemType temp,ZJC_Stack &robot)     //因为要修改值，所以取地址，开始没加取地址符号，栈顶元素一直是(1,1)  
{  
    temp.x = i,temp.y = j;  
    Push(robot,temp);  
    MAP[i][j] = 2;                      //标记已经走过该格子了,当初想是否需要用其他标记，实际上不需要的，既然标记2，那么证明当然可以走过(不是墙)!  
}  
void MAZH_SOLVE(int endx,int endy)      //解决迷宫问题函数,参数为终点的坐标  
{                             
    int i = 0,j = 0;                    //起点坐标    
    ZJC_Stack robot;                    //定义栈；  
    if(InitStack( robot ) )             //初始化栈  
        printf("\n栈的初始化完成....\n");                                        
    ElemType CurrentPos ;               //当前位置         
    ElemType start;                     //初始位置的相关信息  
    ElemType temp;                      //暂时用的  
    start.x = i;  
    start.y = j;  
    temp = start;  
    
    MAP[i][j] = 2;                      //走过的标记为2             
    Push(robot,start);                  //初始位置入栈  

    printf("\n开始寻路....\n");   
    do                                  //主要寻路算法：  
    {  
          
          CurrentPos = GetTop(robot);  
          i = CurrentPos.x;  
          j = CurrentPos.y;  
          printf(" \n寻路过程如下栈顶元素的 x = %d ,y = %d....\n",i,j);  
          
		  if(MAP[i][j+1] && MAP[i][j+1] == 1)          //表明向下一格走得通  
          {                                       
              printf("\n向下能走动");    //向下前进一步，压栈，标记  
              j++;  
              PathAddToStack(i,j,temp,robot);                             
          }  
          else if( MAP[i + 1][j] && MAP[i + 1][j] == 1)         
          {  
               printf("\n向右能走动");  
                i++;                           
                PathAddToStack(i,j,temp,robot);  
          }  
          else  if(MAP[i - 1][j] && MAP[i - 1][j] == 1)          
          {  
               printf("\n向左能走动");  
                i--;                           
                PathAddToStack(i,j,temp,robot);  
          }  
          else if(MAP[i][j - 1] && MAP[i][j - 1] == 1)          
          {  
               printf("\n向上能走动");  
                j--;                           
                PathAddToStack(i,j,temp,robot);  
          }  
          else  //都走不动  
          {  
               printf("\n都走不动，退栈");                           
               Pop(robot,temp);  
          }  
      
    }while( GetTop(robot).x != endx || GetTop(robot).y != endy);        //只要栈顶元素的x,y不等于终点坐标的x,y,则一直循环找路径  
    printf("\n完成!\n");  

    Print_Path(robot);		//打印出坐标值                               
}  



int main()    //入口函数  
{      
    MAZH_SOLVE(6,6);       
    return 0;  
}



雪人_LV
关注
专栏目录
数据结构知识点总结05-(第三章.栈和队列)-栈的定义、基本操作、相关应用
随风浪仔的专栏
02-26 245
数据结构知识点总结05-(第三章.栈和队列)-栈的定义、基本操作、相关应用。栈和队列，是一种操作受限的线性表，正因为它的操作受限，才使得它的应用面更广泛，通常通用的模型应用并不广泛，比如数学公式、定理，应用的比较多的是特殊化的公式。
迷宫问题 C语言 超详细具体解题过程 地下迷宫
fengliang_v的博客
07-28 3290
牛客网上的迷宫问题没怎么看到c语言的解答版本也是数据结构栈的一个实际应用场景，值得学习 本篇文章主要解题思路在注释上，跟着代码一步步下去，再结合注释，应该不是很难理解。
栈的应用--迷宫问题
Tattoo的博客
10-18 3559
问题描述：给定一个迷宫，给定入口和出口，找到从入口到出口的一条路径(任何一条路径都可以)，迷宫为0表示可走，为1表示墙。用1将迷宫围起来避免边界问题。实现思路：1.DFS搜索（递归）2.采用栈的数据结构下面分别用这两种方法来解决这个问题。DFS搜索（即递归+回溯）#include<stdio.h> #include<stdlib.h> #include<string.h> #include <uni
算法基础（二）：栈的应用--迷宫解题（超详细版！）
Less Is More
02-28 4661
算法基础（二）：栈的应用--迷宫解题（超详细版！）。（注：为了不离开本节讨论的重点--栈，迷宫的自动生成以后重新写。这里用简单的二维数组代替，手动迷宫，呵呵！） MAP里面0代表墙（通不过），1代表空格（可通过）代码中每一步有详细注释。欢迎大家交流，嘻嘻。
栈的应用——迷宫
wm12345645的博客
04-20 169
本文共总结三个方法：1，  迷宫不带环（循环法）2，迷宫不带环（递归法）3，迷宫带环（递归法）  一，迷宫不带环（循环法）的基本思路：  通过栈来保存路径，首先将初始位置入栈，后用取出栈顶元素的方式，得到初始位置，  然后进入while循环，循环内有4种情况，找到出口，向四个方向走动，走错了，找                 不到出口（栈空了）。     若可以向四个方向走通，则将next位置入...
栈的应用_迷宫求解
孟凡驰的博客
03-22 1763
标题： 迷宫问题 时 限： 100000 ms 内存限制： 100000 K 总时限： 3000 ms 描述： 迷宫问题 迷宫是一个二维矩阵,其中1为墙,0为路,3为入口,4为出口.要求从入口开始,从出口结束,按照 下,左,上,右 的顺序来搜索路径. 输入： 迷宫宽度w 迷宫高度h 迷宫第一行 迷宫第二行 ...
栈的应用——迷宫问题
Android茶话会
10-10 1376
这里结合了栈+深度优先算法
数据结构的案例教学——栈在“迷宫问题”中的应用.pdf
08-07
迷宫问题是一个古老而有趣的问题，通过将栈应用于迷宫的路径搜索中，可以直观地理解栈的工作原理及其在解决复杂问题时的应用。 案例教学法是一种教学模式，通过将理论知识与实际案例相结合的方式，提高学生的学习...
迷宫问题_迷宫问题_栈_
09-30
本篇文章将详细探讨迷宫问题以及栈的应用。 迷宫问题的核心是路径搜索，我们可以采用深度优先搜索（DFS，Depth-First Search）策略来解决，而DFS算法正好可以借助栈来实现。迷宫通常被表示为一个二维矩阵，其中0...
bfs的应用案例-迷宫问题
weixin_43679657的博客
03-04 186
题目描述 东东有一张地图，想通过地图找到妹纸。地图显示，0表示可以走，1表示不可以走，左上角是入口，右下角是妹纸，这两个位置保证为0。既然已经知道了地图，那么东东找到妹纸就不难了，请你编一个程序，写出东东找到妹纸的最短路线。 Input 输入是一个5 × 5的二维数组，仅由0、1两数字组成，表示法阵地图。 Output 输出若干行，表示从左上角到右下角的最短路径依次经过的坐标，格式如样例所示。数据...
栈的应用之迷宫问题
legend050709的专栏
06-05 721
/************************************************************************/ /*自定义栈                                                                         */ /*通过自定义的简单栈以满足迷宫求解                */ /*功
栈的应用-迷宫
weixin_30326741的博客
07-12 93
看到一个有意思的题目：给一个迷宫，并给定迷宫的起点和终点，然后求出迷宫从入口到出口的路径。 解题思路是这样： 从入口开始，每次沿逆时针方向进行判断，我们总共有四个方向（0.1.2.3），如果方向0不能走，那么我们就试方向1，一直试到可以走的方向。当某一个方向可以走的时候，我们可以往前走一格，然后再进行判断。那么，当然，我们很有可能走到一个死胡同，死胡同的定义是，除了我们来的那个方向，其他三个方...
栈的应用--迷宫求解
qq_50804645的博客
05-29 3328
栈的应用–迷宫求解 思路: 从一个起点(1,1)坐标开始, 依次判断它的右,下,左,上, 方位能不能走 如果能就直接走, 每走一步将这个位置的坐标入栈, 并且标记为2, 若都不能走, 说明走到死路了, 要开始回溯,走过没有走过标记为3 回溯时就是把入栈的坐标出栈, 即可原路返回, 每返回一步就重新再判断它的 右,下,左,上, 能不能走,直到找到终点(8,8)坐标,否则没有通路 #include <stdio.h> #include <stdlib.h> #include &l
迷宫问题（寻路）和状态空间搜索
weixin_30263073的博客
08-14 315
迷宫问题以及状态空间搜索的实现，有赖于栈和队列这些数据结构的支持。 1. 解迷宫问题 解迷宫问题是一种常见智力游戏，也可以视为许多实际问题的反映和抽象。例如： 在公路网或铁路网上查找可行的或最优的路线； 电子地图的路径检索； 计算机网络传输的路由检索； 对于迷宫问题，一般是给定一个迷宫图，包括图中的一个入口点和出口点，要求在图中找到一条从入口到...
栈的应用 —— 迷宫问题
热门推荐
一枚野生程序员 —— Tim
08-17 3万+
题目 这是几个由二维数组构成的迷宫，简单的迷宫，多通路不带环的迷宫，多通路带环的迷宫！对于简单迷宫我们需要判断是否有出口！对于多通路不带环的迷宫我们需要确定出口并且判断最短路径，对于通路间带环的迷宫我们需要找出最短路径！ 算法思想：回溯 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜...
用栈求解迷宫问题
Sunflower的博客
08-11 9945
求解迷宫问题 问题描述 求迷宫问题就是求出从入口到出口的路径。在求解时,通常用的是“穷举求解”的方法，即从入口出发，顺某一方向向前试探,若能走通,则继续往前走；否则沿原路退回，换一个方向再继续试探,直至所有可能的通路都试探完为止。为了保证在任何位置上都能沿原路退回（称为回溯），需要用一个后进先出的栈来保存从入口到当前位置的...
迷宫寻路问题——A*算法
DiamonJoy
03-24 2万+
迷宫寻路问题是人工智能中的有趣问题，如何表示状态空间和搜索路径是寻路问题的重点，本文的主要内容是A*搜索算法的理解和应用，首先对基本知识和算法思想进行了解，再通过其对迷宫问题求解应用，编写 Python 程序进行深入学习。
数据结构-走迷宫问题（栈的运用）
qq_40251838的博客
06-02 5562
用矩阵代表地图，矩阵中1代表可以走通，0代表可以走通。假设目前位于（x,y）处，则下一可走位置为（）
迷宫
weixin_30951231的博客
07-30 90
#include<stdio.h>#include<stdlib.h>#include<windows.h>#include<conio.h>int main (){ char a[50][50]={"######", "#o # ", "# ## #", "# # #", "##...
栈与队列解决小型迷宫问题
"小型迷宫数据结构问题，涉及栈与队列的概念及应用，迷宫解题策略通过栈实现回溯。" 在计算机科学中，数据结构是组织、管理和存储数据的方式，它对于高效地执行算法至关重要。在这个问题中，我们关注的是两种基本的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值