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

于 2021-08-26 14:25:55 发布
阅读量247 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： linux_arm 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wowocpp/article/details/119930701
本文讲解了如何使用栈实现算法3.3，解决10x10迷宫中从指定入口到出口的路径问题，包括坐标结构定义、角色移动规则、路径标记与检查等功能。通过步骤演示了如何标记不可通区域并追踪足迹。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

数据结构 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");
   }    

   
}

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

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值