简单迷宫(链栈)

最新推荐文章于 2022-04-09 23:56:02 发布
最新推荐文章于 2022-04-09 23:56:02 发布
阅读量548 收藏 1
点赞数
文章标签： null path
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lwwworkspace/article/details/6502878
版权

Stack.h

Code:
  1. #ifndef STACK_H_H   
  2. #define OK  0   
  3. #define ERROR   -1   
  4.   
  5. typedef struct Point   
  6. {   
  7.     int x;   
  8.     int y;   
  9. }Point;   
  10.   
  11. typedef struct Stack   
  12. {   
  13.     Point pt;       //保存坐标点   
  14.     struct Stack *next;   
  15. }*LinkStack;   
  16.   
  17. int init_linkStack(LinkStack*);   
  18. int make_node(Stack**);   
  19. int clear_linkStack(LinkStack);   
  20. int destroy_linkStack(LinkStack*);   
  21. int push(LinkStack, Point);   
  22. int pop(LinkStack, Point*);   
  23. int create_linkStack(LinkStack);   
  24. int print_linkStack(LinkStack);   
  25. int get_top(LinkStack, Stack**);   
  26. int stack_empty(LinkStack);   
  27. #endif  

Stack.cpp

Code:
  1. #include<stdio.h>   
  2. #include<stdlib.h>   
  3. #include "Stack.h"   
  4.   
  5. int init_linkStack(LinkStack *lstack)   
  6. {   
  7.     if(!((*lstack) = (LinkStack)malloc(sizeof(Stack))))   
  8.         return ERROR;   
  9.     (*lstack)->pt.x = 0;   
  10.     (*lstack)->pt.y = 0;   
  11.     (*lstack)->next = NULL;   
  12.     return OK;   
  13. }   
  14.   
  15. int make_node(Stack **node)   
  16. {   
  17.     if(!((*node) = (LinkStack)malloc(sizeof(Stack))))   
  18.         return ERROR;   
  19.     (*node)->pt.x = 0;   
  20.     (*node)->pt.y = 0;   
  21.     return OK;   
  22. }   
  23.   
  24. int clear_linkStack(LinkStack lstack)   
  25. {   
  26.     if(lstack == NULL || lstack->next == NULL)   
  27.         return ERROR;   
  28.     Stack *tmp = lstack->next;   
  29.     Stack *tmp1;   
  30.     while(tmp != NULL)   
  31.     {   
  32.         tmp1 = tmp;   
  33.         tmp = tmp->next;   
  34.         free(tmp1);   
  35.     }   
  36.     lstack->next = NULL;   
  37.     return OK;   
  38. }   
  39.   
  40. int destroy_linkStack(LinkStack *lstack)   
  41. {   
  42.     if((*lstack) == NULL)   
  43.         return ERROR;   
  44.     Stack *tmp;   
  45.     while((*lstack) != NULL)   
  46.     {   
  47.         tmp = *lstack;   
  48.         (*lstack) = (*lstack)->next;   
  49.         free(tmp);   
  50.     }   
  51.     (*lstack) = NULL;   
  52.     return OK;   
  53. }   
  54.   
  55. int push(LinkStack lstack, Point pt)   
  56. {   
  57.     if(lstack == NULL)   
  58.         return ERROR;   
  59.     Stack *node;   
  60.     if(make_node(&node))   
  61.         return ERROR;   
  62.     node->pt = pt;   
  63.     node->next = lstack->next;   
  64.     lstack->next = node;   
  65.     return OK;   
  66. }   
  67.   
  68. int pop(LinkStack lstack, Point *pt)   
  69. {   
  70.     if(lstack == NULL || lstack->next == NULL)   
  71.         return ERROR;   
  72.     Stack *tmp;   
  73.     *pt = lstack->next->pt;   
  74.     tmp = lstack->next;   
  75.     lstack->next = tmp->next;   
  76.     free(tmp);   
  77.     return OK;   
  78. }   
  79.   
  80. int create_linkStack(LinkStack lstack)   
  81. {   
  82.     if(lstack == NULL || lstack->next != NULL)   
  83.         return ERROR;   
  84.     Point pt;   
  85.     printf("input x, y: ");   
  86.     scanf("%d,%d",&pt.x, &pt.y);   
  87.     while(0 != pt.x && 0 != pt.y)   
  88.     {   
  89.         push(lstack,pt);       
  90.         scanf("%d,%d",&pt.x, &pt.y);   
  91.     }   
  92.     return OK;   
  93. }   
  94.   
  95. int print_linkStack(LinkStack lstack)   
  96. {   
  97.     if(lstack == NULL || lstack->next == NULL)   
  98.         return ERROR;   
  99.     Stack *tmp = lstack->next;   
  100.     while(tmp != NULL)   
  101.     {   
  102.         printf("(%d,%d), ",tmp->pt.x, tmp->pt.y);   
  103.         tmp = tmp->next;   
  104.     }   
  105.     printf("/n");   
  106.     return OK;   
  107. }   
  108.   
  109. int get_top(LinkStack lstack, Stack **node)   
  110. {   
  111.     if(lstack == NULL || lstack->next == NULL)   
  112.         return ERROR;   
  113.     *node = lstack->next;   
  114.     return OK;   
  115. }   
  116.   
  117. int stack_empty(LinkStack lstack)   
  118. {   
  119.     if(lstack == NULL)   
  120.         return ERROR;   
  121.     if(lstack->next == NULL)   
  122.         return true;   
  123.     return false;   
  124. }  

mg.h

Code:
  1. #ifndef MG_H_H   
  2. #define MAX_SIZE    10   
  3. #define OK  0   
  4. #define ERROR   -1   
  5.   
  6. int create_map(int map[MAX_SIZE][MAX_SIZE], int);   
  7. int print_map(int map[MAX_SIZE][MAX_SIZE]);   
  8. int maze_path(int map[MAX_SIZE][MAX_SIZE], Point, Point);   
  9. #endif  

mg.cpp

Code:
  1. #include<stdlib.h>   
  2. #include<stdio.h>   
  3. #include<time.h>   
  4. #include "Stack.h"   
  5. #include"mg.h"   
  6.   
  7. int create_map(int map[MAX_SIZE][MAX_SIZE], int num)   
  8. {   
  9.     //初始化地图   
  10.     for(int i = 0 ; i < MAX_SIZE ; i++)   
  11.     {   
  12.         for(int j = 0 ; j < MAX_SIZE ; j++)   
  13.         {   
  14.             if(j == 0 || i == 0   
  15.                 || j == MAX_SIZE - 1 || i == MAX_SIZE - 1)   
  16.             {   
  17.                 map[i][j] = 1;   
  18.             }   
  19.             else  
  20.                 map[i][j] = 0;   
  21.         }   
  22.     }   
  23.   
  24.     //产生地图障碍   
  25.     srand(time(0));   
  26.     while(num > 0)   
  27.     {   
  28.         int m = rand() % MAX_SIZE;   
  29.         int n = rand() % MAX_SIZE;   
  30.         map[m][n] = 1;   
  31.         num--;   
  32.     }   
  33.     return OK;   
  34. }   
  35.   
  36. int print_map(int map[MAX_SIZE][MAX_SIZE])   
  37. {   
  38.     for(int i = 0 ; i < MAX_SIZE ; i++)   
  39.     {   
  40.         for(int j = 0 ; j < MAX_SIZE ; j++)   
  41.             printf("%d ",map[i][j]);   
  42.         printf("/n");   
  43.     }   
  44.     return OK;   
  45. }   
  46.   
  47. int maze_path(int map[MAX_SIZE][MAX_SIZE], Point start, Point end)   
  48. {   
  49.     LinkStack lstack;   
  50.     Stack *node;   
  51.     init_linkStack(&lstack);   
  52.     Point people = start;   
  53.     push(lstack,people);   
  54.     do  
  55.     {   
  56.         //行走的路径放在栈中   
  57.         if(people.x == end.x && people.y == end.y)   
  58.             break;   
  59.         if(map[people.x][people.y + 1] != 1)   
  60.         {   
  61.             people.y += 1;   
  62.             push(lstack,people);   
  63.             //走过的路径做下标记   
  64.             map[people.x][people.y] = 1;   
  65.         }   
  66.         else if(map[people.x + 1][people.y] != 1)   
  67.         {   
  68.             people.x += 1;   
  69.             push(lstack,people);   
  70.             get_top(lstack,&node);   
  71.             map[people.x][people.y] = 1;   
  72.         }   
  73.         else if(map[people.x][people.y - 1] != 1)   
  74.         {   
  75.             people.y -= 1;   
  76.             push(lstack,people);   
  77.             map[people.x][people.y] = 1;   
  78.   
  79.         }   
  80.         else if(map[people.x - 1][people.y] != 1)   
  81.         {   
  82.             people.x -= 1;   
  83.             push(lstack,people);   
  84.             map[people.x][people.y] = 1;   
  85.         }   
  86.         else       
  87.         {   
  88.             pop(lstack,&people);   
  89.         }   
  90.     }while(!stack_empty(lstack));   
  91.   
  92.     if(!stack_empty(lstack))   
  93.     {   
  94.         while(!stack_empty(lstack))   
  95.         {   
  96.             pop(lstack,&people);   
  97.             printf("(%d,%d) ", people.x, people.y);   
  98.         }   
  99.         printf("/n");   
  100.     }   
  101.     else  
  102.     {   
  103.         printf("not found the outlet./n");   
  104.     }   
  105.     return OK;   
  106. }  

Main.cpp

Code:
  1. #include<stdio.h>   
  2. #include<stdlib.h>   
  3. #include "Stack.h"   
  4. #include "mg.h"   
  5.   
  6. void main()   
  7. {   
  8.     int map[MAX_SIZE][MAX_SIZE];   
  9.     Point start;   
  10.     Point end;   
  11.     create_map(map,30);   
  12.     print_map(map);   
  13.     printf("input start point (x,y): ");   
  14.     scanf("%d,%d", &start.x, &start.y);   
  15.     printf("input end point (x,y): ");   
  16.     scanf("%d,%d", &end.x, &end.y);   
  17.     maze_path(map, start, end);   
  18. }  

 

lwwworkspace
关注
简简单单小迷宫——随机迷宫+最短路径
yyggs的博客
05-07 1188
简单迷宫 首先，因为C++中没有TC所特有的gotoxy()函数，所以要先自己写一个函数，实现gotoxy()函数输出文本里面光标定位的功能。 其次，按照随机普里姆算法的思想，构建了一个随机迷宫，特点是迷宫全局只有一条通路。 然后，运用递归与队列寻找迷宫的可行路径，可以找到该迷宫的最短路径。（然而我这个随机迷宫只有一条路径，可行即最短） 最后，依靠gotoxy()稍稍优化一下用户界面。 .------------------------------------------------------------
栈求解迷宫问题（python）
Amamiyaren1的博客
10-06 1440
迷宫问题通常是一个简单路径的问题采用枚举法找到所有出口 准备： ①先构造一个box类储存迷宫方块 class box: def __init__(self,i1,j1,di1): self.i = i1 self.j = j1 self.di = di1 ②构建线性栈 class SqStack: def __init__(self): self.data = [] def empty(self): if le
实现简单的迷宫
weixin_33670786的博客
04-11 156
我们知道栈的特点是：后进先出（First In Last Out）;也就是说只能在栈的尾部进行压栈和出栈，而且出栈的时候只能从最后一个数据开始。 所以我们利用栈这个特点，来实现这个迷宫。在这之中我们要采用“回溯”的方法去处理当遇到路径不通的情况。 原理：每找到一个通路，就将这个数据压栈，这样当前位置的上一个位置就位于栈的顶部，假如当前位置的上下左右都找不到通路的时候，...
简单的迷宫问题 ——链栈实现
From now on...的Blogs
11-03 1106
迷宫问题直接dfs或者bfs多easy，非要用自己搞的链栈。。。。 不过思想很类似搜索 #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 typedef int Status; struct node{ int x; int y; }; typedef struct s...
简单迷宫
我的学习笔记
02-03 744
#include #include using namespace std;int s[100][100];int x , y , x0 , x1 , y0 , y1;void so(int y , int x){  if (s[y][x] == 1 || s[y][x] == 2) return;  s[y][x] = 2;  so(y - 1 , x);  so(y , x - 1); 
迷宫+c+链式栈
04-06
在本项目中，"迷宫+c+链式栈"是一个基于C语言实现的数据结构应用，...链式栈在此起到了关键作用，它不仅支持高效的回溯操作，也使得路径的记录变得简单。这样的实现对于理解和掌握数据结构及算法的应用具有很高的价值。
非常简单的C++迷宫程序，是数据结构课程要求的作业。只要会链栈就能看得懂，visual C++6.0写的
10-16
根据给定的文件信息，...综上所述，这个简单的C++迷宫程序不仅展示了链式栈的使用方法，还提供了一个基本的迷宫探索框架，为初学者提供了很好的实践机会。通过进一步的优化和完善，可以让程序变得更加高效和易于理解。
数据结构-栈的应用：顺序栈与链栈的应用
最新发布
03-22
- **优点**：实现简单，访问速度快，因为数组的随机访问特性。 - **缺点**：容量固定，如果预先不知道数据规模，可能会导致空间浪费或溢出问题。 - **操作**：包括push（压栈，向栈顶添加元素）、pop（出栈，移除...
利用栈和队列解决迷宫问题
05-31
3.实现链栈的基本操作：栈在本实验中用于记录解决迷宫的路径，要实现基本的初始化、入栈、出栈和判空等操作。 4.实现链式队列的基本操作：bfs算法借助队列实现迷宫路径的查找，所以要实现基本的初始化、入队、出队等...
利用链式栈结构求迷宫问题所有解：回溯算法，两种输出形式数组输出和三元组输出
06-06
VC6.0，详细注释，编译无误 利用链式栈结构求迷宫问题所有解：回溯算法，两种输出形式数组输出和三元组输出
简单的迷宫
caigaojian的博客
04-20 410
1.迷宫问题 #include  #include  #define BOUNDARY 8 #define MAX 255 char table[8][8]; int start_x,start_y; typedef struct Data{     int maze_x;     int maze_y; }data; typedef st
迷宫问题（一）------简单迷宫
一个脱发少女的日常
08-19 1297
所需知识 递归 结构体 ❀思路分析 如图为一个简单的迷宫地图 简答理解为，数字1代表通路，数字0代表障碍物。 1.怎样创建迷宫地图的信息 创建一个结构体，内放二维数组来保存迷宫地图的坐标 /建立一个地图 typedef int DataType; //迷宫 typedef struct Map { DataType map[ROW][COL]; }M...
简单迷宫(递归)
qq_52351978的博客
04-09 291
代码思路 1.创建二位数组作为迷宫 2.数字1为墙壁，2为经过的位置，3为死路，0为未探寻的位置 3,定义一个起点和终点，运用递归的方法，按照自己设计的寻找方向的优先级运行，直到让终点值为2则返回true，未找到返回false。 4.重新遍历输出二维数组,2的轨迹则为出口路径 代码如下 public class MiGongAPP { public static void main(String[] args) { // TODO 自动生成的方法存根 int[][] map=new
最简单的迷宫求解
superficial
03-16 1435
使用栈对迷宫进行求解，并且使用了探测法和回溯法。
简单迷宫问题
无糖咖啡的博客
01-24 1198
使用C语言实现的一个简单迷宫求解。其中使用了顺序栈数据结构，并且完成了完整的顺序栈功能。
简单迷宫求解
Xucc_x的博客
04-23 1733
问题引出 迷宫求解是栈的典型例子，今天我们来讨论的是简单的迷宫求解问题，即 迷宫只有一个出口，迷宫内的路径不带环，不相交 例如： 回溯法 在正式求解之前，我们要知道一个很重要的概念 回溯法：对一个包括有很多个结点，每个结点有若干个搜索分支的问题，把原问题分解为若干个子问题求解的算法；当搜索到某个结点发现无法再继续搜索下去时，就让搜索过程回溯(回退)到该节点的前一个结点，继...
简单迷宫实验(链栈)
Will的专栏
08-07 601
Stack.h#ifndef STACK_H_H #define OK 0 #define ERROR -1 typedef struct Point { int x; int y; }Point; typedef struct Stack { Point pt; //保存坐标点 struct Stack *next; }*LinkStack; int init_linkStack(LinkStack*); int make_node(Stack**);
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值