数据结构 study 10：迷宫求解 typedef 二维数组

最新推荐文章于 2022-03-27 21:07:49 发布
最新推荐文章于 2022-03-27 21:07:49 发布
阅读量191 收藏 2
点赞数
分类专栏： linux_arm 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wowocpp/article/details/119930701
版权

数据结构 study 10：迷宫求解

page60 ,page50
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

题目解析：

构造一个如图下面的迷宫

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
0表示墙
1表示可以走的路
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

把上面的问题 简单的解析一下

去掉构造迷宫的过程，不用手动输入，
假设是有一个现成的迷宫，这个迷宫固定不变。

这个迷宫的大小是 10x10
这个迷宫的墙用0表示
这个迷宫的路用1表示
有一个 下面的迷宫
在这里插入图片描述
入口坐标是1,1 ，出口坐标是8,8
那么精灵 从1,1 出发，上北下南，左西右东，按照方向优先级 东南西北，这个方向走。
在这里插入图片描述
小精灵 从起点(1,1)开始，按照方向，东南西北，这个方向依次向前走。
每走一格，就将走通的格子，标记一下步数。
遇到走不通的格子，标记为 -1.

精灵的动作，选择方向，走一格子。
是否走通。
如果通，标记格子，放入栈中。
继续选择方向，走下一格子。
如果没有走通，就换向，走下一格子。
如果4个方向都没有走通，标记这个格子为-1

退回上一个格子，选择方向，走一个格子。

看上面的描述：
程序需要，定义一下坐标结构体。

typedef struct /* 迷宫坐标位置类型 /
{
int x; / 行值 /
int y; / 列值 */
}PosType;

还需要定义一下 精灵的结构体：

typedef struct
{
PosType pos;
int direct ; //东南西北
}Role;

PosType direc[4]={{0,1},{1,0},{0,-1},{-1,0}}; /* {行增量,列增量} */

迷宫的格子，0表示墙，1，表示路，大于1，表示步数。
-1 表示虽然是路，但是 这个路，已经走过了，走不通。

迷宫需要提供 如下的功能。

当前坐标的下一个坐标是啥?
PosType NextPos(PosType c,int di)
{
}

对迷宫的格子，进行标记，标记这个格子走不通
void MarkPrint(PosType b)
{
}

走过的迷宫的格子 是第几步
void FootPrint(PosType a)
{

}

迷宫的这个格子 是否 可以通过
Status Pass(PosType b)
{

}

演示 代码如下:
/* c1.h (程序名) */
 #include<string.h>
 #include<ctype.h>
 #include<malloc.h> /* malloc()等 */
 #include<limits.h> /* INT_MAX等 */
 #include<stdio.h> /* EOF(=^Z或F6),NULL */
 #include<stdlib.h> /* atoi() */
 #include <sys/io.h> /* eof() */
 #include<math.h> /* floor(),ceil(),abs() */
 
 #include<pthread.h> /* exit() */
 /* 函数结果状态代码 */
 #define TRUE 1
 #define FALSE 0
 #define OK 1
 #define ERROR 0
 #define INFEASIBLE -1
 /* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */
 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
 typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
 
 int curstep=1; /* 当前足迹,初值为1 */



typedef enum {RIGHT, DOWN, LEFT,UP} direct_t;


/* algo3-5.c 利用栈求解迷宫问题（只输出一个解，算法3.3） */
 typedef struct /* 迷宫坐标位置类型 */
 {
   int x; /* 行值 */
   int y; /* 列值 */
 }PosType;

typedef struct 
{
    PosType pos ;
    direct_t direct ; // 0,1,2,3 东南西北 顺时针
}Role ;

 #define MAXLENGTH 10 /* 设迷宫的最大行列为10 */
 typedef int MazeType[MAXLENGTH][MAXLENGTH]; /* 迷宫数组[行][列] */

 /* 全局变量 */
 /* 迷宫数组 */
 MazeType m = 
 {
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  0,  1,  1,  0,  1,  1,  1,  0,  1,  0,
  0,  1,  1,  0,  1,  1,  1,  0,  1,  0,
  0,  1,  1,  1,  1,  0,  0,  1,  1,  0,
  0,  1,  0,  0,  0,  1,  1,  1,  1,  0,
  0,  1,  1,  1,  0,  1,  1,  1,  1,  0,
  0,  1,  0,  1,  1,  1,  0,  1,  1,  0,
  0,  1,  0,  0,  0,  1,  0,  0,  1,  0,
  0,  0,  1,  1,  1,  1,  1,  1,  1,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0

 }; 

void Print(int x,int y)
{ /* 输出迷宫的解 */
  int i,j;
  for(i=0;i<x;i++)
  {
    for(j=0;j<y;j++)
      printf("%3d",m[i][j]);
    printf("\n");
  }
}

void Print_Path(void)
{ /* 输出迷宫的解 */
  int i=0,j=0;

  printf("\n------------curstep = %d----------\n",curstep);  
  for(i=0;i<10;i++)
  {
    for(j=0;j<10;j++)
      printf("%3d",m[i][j]);
    printf("\n");
  }
  printf("\n");
}


Boolean Pass(PosType b)
{
     if(m[b.y][b.x] == 1){

        return TRUE;
     }   

     return FALSE;
}


PosType NextPos(PosType c,int di)
{
  //PosType direct[4]={{0,1},{1,0},{0,-1},{-1,0}}; /* {行增量,列增量} */
  PosType direct[4]={{1,0},{0,1},{-1,0},{0,-1}}; /* {行增量,列增量} */

  c.x += direct[di].x;

  c.y += direct[di].y;

  return c;
}

 void MarkPrint(PosType b)
 { /* 使迷宫m的b点的序号变为-1(不能通过的路径) */
   m[b.y][b.x]=-1;
 }



 void FootPrint(PosType pos,int cur_step)
 { /* 使迷宫m的a点的序号变为足迹(curstep) */
   m[pos.y][pos.x]=cur_step;
 }





 /* c3-1.h 栈的顺序存储表示 */
#define STACK_INIT_SIZE 100 /* 存储空间初始分配量 */
#define STACKINCREMENT 2 /* 存储空间分配增量 */

typedef Role ElemType  ;


typedef struct sqStack
{
    ElemType *top ;
    ElemType *base ;

    int stack_size ;
}sqStack ;




Status init_stack(sqStack *S)
{
    S->base = (ElemType *)malloc(sizeof(ElemType)*STACK_INIT_SIZE);

    S->top = S->base ;

    S->stack_size = STACK_INIT_SIZE ;

    return OK;
}


Status push_stack(sqStack *S, ElemType e)
{
    if(S->top - S->base < S->stack_size){

        *(S->top++) = e ;
        
        return OK ;
    }

    return ERROR;
}

Status pop_stack(sqStack *S, ElemType *e)
{

    if(!empty_stack(S)){

        *e = *(--(S->top));

        return OK;
    }

    return ERROR;
}


Boolean empty_stack(sqStack *S)
{
    if(S->top == S->base){

        return TRUE;
    }

    return FALSE ;
}

Status clear_stack(sqStack *S)
{
   (*S).top=(*S).base;
   return OK;
}

Status destroy_stack(sqStack *S)
{
   free((*S).base);
   (*S).base=NULL;
   (*S).top=NULL;
   (*S).stack_size=0;
   return OK;
}


void visit(ElemType e)
{
    //fputc(e,fp);
}

Status traverse_stack(sqStack *S, void (*visit)(ElemType))
{
    ElemType *pt ; 

    pt = S->base ;
    while(pt < S->top ){

        visit(*(pt++));
    }
}



Status MazePath(PosType start,PosType end)
{

    Role role ;

    sqStack S;

    init_stack(&S);

    PosType nextPos ;
    role.pos = start ;
    role.direct = RIGHT;

    curstep = 1;

    while(1){

        Print_Path(); 
        nextPos = NextPos(role.pos, role.direct);
        if(Pass(nextPos)){
            
            push_stack(&S,role);  

            FootPrint(role.pos, curstep);
            curstep++ ;            

            if(nextPos.x == end.x && nextPos.y == end.y){
                
                break ;
            }
            
            role.pos = nextPos;       
            role.direct = RIGHT;


        }else{
            
            /*下一步不是通的*/
  
            
            if(role.direct ==3){

                /*4个方向都试过了，退回上一个格子*/
            
                MarkPrint(role.pos);
                curstep-- ;
                
                if(!empty_stack(&S)){

                    pop_stack(&S,&role); 
                    
                }else{

                    return ERROR;
                }
                
            }else{
                /*换个方向*/
                role.direct++;
            }
        }
            
    }

    
    return OK;
}


int main()
{
    PosType begin,end;
    int x;
    int y;
    x = 10;
    y = 10;

    printf("迷宫的布局为:\n");
    Print(x,y);

   begin.x = 1;
   begin.y = 1;

   end.x = 8;
   end.y = 8;    
   
   if(MazePath(begin,end)) /* 求得一条通路 */
   {
     printf("此迷宫从入口到出口的一条路径如下:\n");
     Print(x,y); /* 输出此通路 */
   }
   else{
     printf("此迷宫没有从入口到出口的路径\n");
   }    

   
}

严蔚敏 数据结构 和 高一凡 数据结构解析 结合学习，搭配使用，效果更佳

wowocpp
关注
专栏目录
二维数组数据结构分析.pdf
08-07
二维数组是一种常见的数据结构，在计算机科学中，它用于存储数据元素的集合，这些元素通常以行和列的形式组织。在数学和计算机科学中，二维数组可由两种不同的概念模型表示：矩阵和数组的数组。矩阵是一种特殊类型的...
数据结构迷宫问题
Starry_皮皮星
04-04 813
【问题描述】 有一个 10 x 10 的迷宫，起点是‘S’，终点是‘E’，墙是‘#’，道路是空格。一个机器人从起点走到终点。当机器人走到一个通道块，前面已经没有路可走时，它会转向到当前面向的右手方向继续走。如果机器人能够过，则留下足迹‘*’，如果走不通，则留下标记‘!’。 下面给出算法，请你模拟机器人的走法输出最终的状态。 【输入形式】 一个 10 x 10 的二维字符数组。 【输出形式】...
数据结构迷宫问题(链式栈)
addddddddddd的博客
11-08 1373
链式栈结构的实现 #include"fstream" #include<string> #include<iostream> using namespace std; #define OK 1 #define ERROR 0 typedef int SElemType; typedef int Status; typedef struct SNode {//链式存储栈...
走迷宫（数据结构，栈的应用）
rasha1123的博客
03-27 2026
【问题描述】 有一个 10 x 10 的迷宫，起点是‘S’，终点是‘E’，墙是‘#’，道路是空格。一个机器人从起点走到终点。当机器人走到一个通道块，前面已经没有路可走时，它会转向到当前面向的右手方向继续走。如果机器人能够过，则留下足迹‘*’，如果走不通，则留下标记‘!’。 下面给出算法，请你模拟机器人的走法输出最终的状态。 【输入形式】 一个 10 x 10 的二维字符数组。 【输出形式】 机器人走过的路径状态。 【样例输入】 ########## #S # # # # # # # ...
数据结构（10）：栈的迷宫问题的实现
欢迎来到关关雎鸠儿的博客
08-14 230
问题描述 迷宫的描述： 用一个二维数组表示一个迷宫，这个二维数组的每一个元素的上下左右以及对角线上的四个方向，这总共加起来是八个方向，其中数字0表示可以通过，数字1表示此处不通，判断给定的一个迷宫是否有出路，有出路的话，求解出走出的路线。 搜索一直切换向东邻方块，若走不通则新的位置为沿着顺时针旋转找到栈顶位置的下一相邻块。 测试数据左上角表示入口，右下角表示出口，若没有可走通路，那么输出“没有找到...
数据结构 迷宫 代码
JordanNotes
12-07 3668
#include #include #include #include #define STACK_INIT_SIZE 1000 #define STACKINCREMENT 10 #define OK 1 #define OVERFLOW 0 #define ERROR 0   //typedef int SElemType; typedef struct SElemTyp
C语言二维数组中的查找的实例
08-29
我们还使用了 showAry 函数来显示二维数组的内容，方便用户了解数组的结构。 在 find 函数中，我们首先判断数组是否为空，如果为空，则直接返回 FALSE。然后，我们使用两个指针 i 和 j 来遍历数组，从右上角的数字...
数据结构教学课件：第8讲 数组.pdf
06-01
数组是数据结构的基础元素之一，它是一种线性数据结构，其中的元素具有相同的数据类型，并通过索引来访问。数组的定义是基于固定大小的元素集合，这些元素可以通过一个或多个整数索引进行定位。在第8讲中，我们重点...
数据结构迷宫求解
12-08
2. **数据结构的选择**：在实现迷宫求解时，常用的数据结构包括数组（或矩阵）来表示迷宫，栈用于回溯（DFS），队列用于广度优先遍历（BFS）。另外，还可以使用链表、二叉树等数据结构来辅助实现某些特定算法。 3. ...
数据结构：迷宫（简单易懂）
稀饭
10-14 9824
讲解： 一。设置地图 用 0 表示可通，用1表示障碍物(不可通) 二。思想：就是让 人 在迷宫里面向上，向下，向左，向右(这四个顺序，你也可以随意安排向上，向下，向左，向右的顺序)的走动，每一次走都要让人走没有走过的地方，所以我们在这里将人走过的地方设置为1，​​​​​​在此我们假设，人向上走，一直走，知道碰到 1(障碍物)，则人先向下，发现下方的那个地方是数字1(即为障碍物)，于是人选择向...
gets函数，C语言gets函数详解
热门推荐
abc
08-24 14万+
gets函数，C语言gets函数详解 在前面从键盘输入字符串是使用 scanf 和 %s。其实还有更简单的方法，即使用 gets() 函数。该函数的原型为： # include <stdio.h> char *gets(char *str); 这个函数很简单，只有一个参数。参数类型为 char* 型，即 str 可以是一个字符指针变量名，也可以是一个字符数组名。 gets() 函数的功能是从输入缓冲区中读取一个字符串存储到字符指针变量 str 所指向的内存空间。 下面将前面中使用 scanf
数据结构的度
abc
08-06 1万+
1 (l) 结点：树中的一个独立单元。包含一个数据元素及若于指向其子树的分支，如图5.1 (b) 中的A 、B 、C 、D 等。（下面术语中均以图5.1 (b) 为例来说明） (2)结点的度：结点拥有的子树数称为结点的度。例如，A的度为3, C的度为l, F的度 为0。 (3)树的度： 树的度是树内各结点度的最大值。图5.1 (b) 所示的树的度为3。 (4) 叶子：度为0 的结点称为叶子或终端结点。结点K 、L 、F 、G 、M 、I 、J都是树的 叶子。 (5) 非终端结点：度不为0 的结点称为非终
数据结构 study 7： 栈 实现 十进制 转换为 8进制
abc
08-24 9982
数据结构 study 6： 栈 实现 十进制 转换为 8进制
如何发现网络中的设备 设备发现协议(收集)
abc
04-20 8612
如何发现网络中的设备(收集) 如何发现网络中的设备(收集) 好吧，每次要SSH到树莓派都很麻烦，我是没找什么办法，每次都得连上显示器鼠标键盘。才能知道IP地址。 看了点python，写了个脚本来发出 ip 地址。这样就省事多了。 缺陷：发现启动时有可能早于树莓派网络初始化，会导致UDP服务初始化出现问题。脚本里面延时 30秒执行。 在树莓派4 测试通过。 =================配置树莓派 SSH登录树莓派 sudo nano /etc/rc/local 输入python脚本 重启树莓派 这个时候
ppp默认 路由设置
abc
05-20 7935
有两种方法： 1、在拨号前将默认路由删除（如果已经存在默认路由，pppd拨号是不会修改这个的，具体解释见How to hook up PPP in Linux的no default route）。 2、将ppp0设置为默认路由。 先删除原来路由，route del default 再将ppp0设置为默认路由，route add default dev ppp0 ...
自己实现一个简单的数据库
abc
07-20 6917
How do you build a database? (self.Database) How do you build a database? (self.Database) Its a great question, and deserves a long answer. Most database servers are built in C, and store data using B-tree type constructs. In the old days there was a produ
ubuntu avahi用法
abc
04-23 5901
ubuntu avahi用法 在 ubuntu 16.04 中已经自带 avahi 服务了 如果没有 请使用 下面命令 安装 sudo apt-get install avahi-daemon sudo apt-get install avahi-utils http://avahi.org/ http://en.wikipedia.org/wiki/Avahi_%28software%29 service avahi-daemon stop 可以查看局域网内所有的mdns服务， avahi-browse
数学中 对数log 指数
abc
08-12 5894
数学中 对数log 指数 如果a的x次方等于N（a>0，且a≠1），那么数x叫做以a为底N的对数（logarithm），记作x=loga N。其中，a叫做对数的底数，N叫做真数。 log函数就是次方函数的逆运算的。y=2x,这就是一个次方函数。y=2x的逆函数就是x=log2y。 ...
数据结构 study 8：括号匹配的检验
abc
08-25 4600
检验括号是否匹配 检验括号匹配的方法，就是对给定的字符串依次检验：若是左括号，入栈；若是右括 号，出栈一个左括号判断是否与之相匹配；是其它字符，不检验。检验到字符串尾，还要 检查栈是否空。只有栈空，整个字符串才匹配完。 括号（()、[]和{}）匹配的检验 请输入带括号（()、[]和{}）的表达式 {[(5-2)*(7-3)+2]*4+8}*6 题目解析 (1)程序 提示 用户 ，手动输入 字符串 (2)对输入的字符串，逐个判断 如果是括号() [] {} ,包含 大括号，中括号，小括号 如果是左括号，就
C语言生成10*10的迷宫
最新发布
03-25
本篇回答由 AI 辅助生成 以下是一个生成10*10的迷宫的示例代码： ```c #include <stdio.h> #include <stdlib.h> #include <time.h> #define WIDTH 10 #define HEIGHT 10 void printMaze(int maze[][WIDTH]) { // 打印迷宫函数 int i, j; for (i = 0; i < HEIGHT; i++) { for (j = 0; j < WIDTH; j++) { printf("%d ", maze[i][j]); } printf("\n"); } } void initMaze(int maze[][WIDTH]) { // 初始化迷宫函数 int i, j; for (i = 0; i < HEIGHT; i++) { for (j = 0; j < WIDTH; j++) { maze[i][j] = 1; // 初始化为墙壁 } } } void generateMaze(int maze[][WIDTH], int x, int y) { // 生成迷宫函数 // 定义方向数组 int dx[4] = {0, 1, 0, -1}; // dx 对应 x 方向 int dy[4] = {-1, 0, 1, 0}; // dy 对应 y 方向 // 打乱方向数组 int i, j, k; for (i = 0; i < 4; i++) { j = rand() % 4; k = dx[i]; dx[i] = dx[j]; dx[j] = k; k = dy[i]; dy[i] = dy[j]; dy[j] = k; } // 扫描 4 个方向 for (i = 0; i < 4; i++) { int nx = x + dx[i]; // 下一个点的 x，y 坐标 int ny = y + dy[i]; if (nx >= 0 && nx < WIDTH && ny >= 0 && ny < HEIGHT && maze[ny][nx] == 1) { maze[y + dy[i] / 2][x + dx[i] / 2] = 0; // 打通路径 maze[ny][nx] = 0; generateMaze(maze, nx, ny); // 递归调用，生成更多的路径 } } } int main() { int maze[HEIGHT][WIDTH]; srand((unsigned)time(NULL)); // 设置随机数种子 initMaze(maze); maze[0][0] = 0; generateMaze(maze, 0, 0); printMaze(maze); return 0; } ``` 代码说明： 1. 首先定义了迷宫的宽和高。 2. 然后定义了三个函数：打印迷宫函数，初始化迷宫函数和生成迷宫函数。 3. 在主函数中，首先定义一个随机数种子并初始化迷宫，然后在左上角设置一个入口点为通路，并通过递归调用 `generateMaze()` 函数来生成更多的路径。最后，打印迷宫。 运行程序，将输出一个大小为 10*10 的迷宫。其中，0 表示可通行，1 表示墙壁。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值