数据结构：栈应用_求解迷宫问题2

最新推荐文章于 2022-11-09 09:15:13 发布
最新推荐文章于 2022-11-09 09:15:13 发布
阅读量126 收藏
点赞数
分类专栏： C/C++ 文章标签： 数据结构 J# UP

/************************************************************************/

/* 数据结构：栈应用：求解迷宫问题                                                                   */

/* 挑灯看剑-shuchangs@126.com 2010-10                                                             */

/* 云歌国际（Cloud Singers International） www.cocoral.com                          */

/************************************************************************/

//上接版面 《数据结构：栈应用_求解迷宫问题1》

 

 

/************************************************************************/

/* 以下为迷宫求解问题                                                                                 */

/************************************************************************/

 

void mazeExperiment()

{

       void printMatrix(int (*mtx)[9], int m, int n);

       void printMzePath(Stack S, int (*mtx)[9], int m, int n);

       static Status visa(CurPos* foot, char direction);

       static void step(CurPos* END, CurPos* foot, Stack* stack, Node* node);

 

       //定义迷宫矩阵，1表示通行，0表示禁止

       //约定迷宫矩阵四壁均为禁止

       int mtx[9][9] =

       {

              {0,0,0,0,0,0,0,0,0},

              {0,1,1,0,1,1,0,1,0},

              {0,1,1,0,1,1,0,1,0},

              {0,1,1,1,1,0,1,1,0},

              {0,1,0,0,0,1,1,1,0},

              {0,1,1,0,0,1,0,1,0},

              {0,1,0,1,1,1,0,1,0},

              {0,1,1,1,1,0,0,1,0},

              {0,0,0,0,0,0,0,0,0}

       };

 

       Stack stack =

       {

              0, NULL, NULL

       };  //定义一个空栈

 

       Node node =

       {

              NULL, NULL, NULL

       };  //用来返回出栈元素

 

       CurPos* foot, * start, * end;//定义足迹指针，开始指针和结束指针

 

       CurPos footprint[9][9];//定义一个足迹矩阵

       int m = 9;//足迹矩阵行数

       int n = 9;//足迹矩阵列数

       COUNT i, j;//足迹坐标

 

       //初始化足迹矩阵

       for (i = 0; i <= m - 1; i++)

       {

              for (j = 0; j <= n - 1; j++)

              {

                     footprint[i][j].data = mtx[i][j];

                     footprint[i][j].visited = FALSE;

                     footprint[i][j].x = i;

                     footprint[i][j].y = j;

                     if (i == 0 && j == 0) //左上顶点

                     {

                            footprint[i][j].up = NULL;

                            footprint[i][j].down = &footprint[i + 1][j];

                            footprint[i][j].left = NULL;

                            footprint[i][j].right = &footprint[i][j + 1];

                     }

                     else if (i == 0 && j == n - 1) //右上顶点

                     {

                            footprint[i][j].up = NULL;

                            footprint[i][j].down = &footprint[i + 1][j];

                            footprint[i][j].left = &footprint[i][j - 1];

                            footprint[i][j].right = NULL;

                     }

                     else if (i == m - 1 && j == 0) //左下顶点

                     {

                            footprint[i][j].up = &footprint[i - 1][j];

                            footprint[i][j].down = NULL;

                            footprint[i][j].left = NULL;

                            footprint[i][j].right = &footprint[i][j + 1];

                     }

                     else if (i == m - 1 && j == n - 1) //右下顶点

                     {

                            footprint[i][j].up = &footprint[i - 1][j];

                            footprint[i][j].down = NULL;

                            footprint[i][j].left = &footprint[i][j - 1];

                            footprint[i][j].right = NULL;

                     }

                     else if (i == 0 && j != 0 && j != n - 1) //上边框

                     {

                            footprint[i][j].up = NULL;

                            footprint[i][j].down = &footprint[i + 1][j];

                            footprint[i][j].left = &footprint[i][j - 1];

                            footprint[i][j].right = &footprint[i][j + 1];

                     }

                     else if (i == m - 1 && j != 0 && j != n - 1) //下边框

                     {

                            footprint[i][j].up = &footprint[i - 1][j];

                            footprint[i][j].down = NULL;

                            footprint[i][j].left = &footprint[i][j - 1];

                            footprint[i][j].right = &footprint[i][j + 1];

                     }

                     else if (j == 0 && i != 0 && i != m - 1) //左边框

                     {

                            footprint[i][j].up = &footprint[i - 1][j];

                            footprint[i][j].down = &footprint[i + 1][j];

                            footprint[i][j].left = NULL;

                            footprint[i][j].right = &footprint[i][j + 1];

                     }

                     else if (j == n - 1 && i != 0 && i != m - 1) //右边框

                     {

                            footprint[i][j].up = &footprint[i - 1][j];

                            footprint[i][j].down = &footprint[i + 1][j];

                            footprint[i][j].left = &footprint[i][j - 1];

                            footprint[i][j].right = NULL;

                     }

                     else //中间元素

                     {

                            footprint[i][j].up = &footprint[i - 1][j];

                            footprint[i][j].down = &footprint[i + 1][j];

                            footprint[i][j].left = &footprint[i][j - 1];

                            footprint[i][j].right = &footprint[i][j + 1];

                     }

              }

       }

 

       start = &footprint[1][1]; //定义起始指针和结束指针，并初始化

       end = &footprint[7][7];

       foot = start;                  //令足迹指针初始指向起始指针

       foot->visited = 1;                //令访问标记为已访问

       StackIn(&stack, *foot);       //当前足迹入栈

       printMzePath(stack, mtx, 9, 9);

       //迷宫遍历规则：每个格子紧挨四个格子，定义为上-下，左-右，按照从右开始、顺时针方向遍历格子

       step(end, foot, &stack, &node); //调用回调函数

       StackPrint(stack, 'B'); //打印栈（迷宫路径）

       printMzePath(stack, mtx, 9, 9);

}

static void step(CurPos* END, CurPos* foot, Stack* stack, Node* rtnNode)

{

       if (foot == END)

       {

              puts("迷宫求解结束！");

       }

       else if (stack->len == 0)

       {

              puts("迷宫求解失败！");

       }

       else if (visa(foot, 'R')) //如果右侧可行，先遍历右方向

       {

              foot->visited = 1; //当前足迹已访问

              StackIn(stack, *foot); //当前足迹入栈

              //StackPrint(*stack, 'B');

              foot = foot->right; //向右前进一步

              step(END, foot, stack, rtnNode);

       }

       else if (visa(foot, 'D'))

       {

              foot->visited = 1;

              StackIn(stack, *foot);

              //StackPrint(*stack, 'B');

              foot = foot->down;

              step(END, foot, stack, rtnNode);

       }

       else if (visa(foot, 'L'))

       {

              foot->visited = 1;

              StackIn(stack, *foot);

              //StackPrint(*stack, 'B');

              foot = foot->left;

              step(END, foot, stack, rtnNode);

       }

       else if (visa(foot, 'U'))

       {

              foot->visited = 1;

              StackIn(stack, *foot);

              //StackPrint(*stack, 'B');

              foot = foot->up;

              step(END, foot, stack, rtnNode);

       }

       else

       {

              foot->visited = 1;

              StackOut(stack, rtnNode); //出栈一位，删除栈顶

              foot = &(rtnNode->data); //foot指针退回到删除结点位置

              //printf("删除结点 foot[%d][%d] = %d\n", foot->x, foot->y,foot->data);

              //StackPrint(*stack, 'B');

              step(END, foot, stack, rtnNode);

       }

}

 

static Status visa(CurPos* foot, char direction)

{

       Status status = FALSE;

       switch (direction)

       {

       case 'L':

              //如果左结点的值可通行，且未被访问

              if (foot->left->data == 1 && foot->left->visited == 0)

                     status = TRUE;

              break;

       case 'R':

              if (foot->right->data == 1 && foot->right->visited == 0)

                     status = TRUE;

              break;

       case 'U':

              if (foot->up->data == 1 && foot->up->visited == 0)

                     status = TRUE;

              break;

       case 'D':

              if (foot->down->data == 1 && foot->down->visited == 0)

                     status = TRUE;

              break;

       default:

              break;

       }

       return status;

}

 

 

void printMatrix(int (*mtx)[9], int m, int n)

{

       COUNT i, j;

       printf("矩阵信息：%d行，%d列！\n", m, n);

       for (i = 0; i < m; i++)

       {

              printf("row=%d   ", i);

              for (j = 0; j < n; j++)

              {

                     printf(" %d ", *(*(mtx + i) + j));

              }

              printf("\n");

       }

}

 

//下接版面 《数据结构：栈应用：求解迷宫问题3》

iteye_12309
关注
专栏目录
数据结构上机实验_栈和队列的应用_迷宫问题 （含代码和报告）
07-18
一． 实验题目：栈和队列的应用 二． 实验内容：迷宫问题 三．实验目的：掌握栈和队列的概念及工作原理，运用其原理完成实验题目中的内容。 四．实验要求：为了使学生更好的掌握与理解课堂上老师所讲的概念与原理，实验前每个学生要认真预习所做的实验内容及编写源程序伪码（写在纸上及盘中均可） 以便在实验课中完成老师所布置的实验内容 五．概要设计原理： 使用穷举求解的方法，即从入口出发，顺某一方向向前探索，若能走通，则继续往前走；否则沿原路退回，换一个方向再继续探索，直至所有可能的通路都被探索为止。
数据结构_栈的应用_迷宫求解问题java实现
叶清逸的博客
08-01 3643
这篇文章讲述的是数据结构部分的迷宫求解问题的java实现，如有错误或者不当之处，还望各位大神批评指正。 问题描述 假设有一个迷宫使用二维数组，墙使用1表示，路径使用0表示，可达路径使用*表示，试写一算法计算出从起点到终点的一条可行路径。 算法分析 使用二维数组存放初始化的迷宫 借助栈来遍历迷宫的路径，栈中保存的是正确的路径 业务逻辑如下 while(栈不为空){ i...
算法用回溯法解决迷宫问题
06-23
对于给定迷宫（n*n），和一个起始坐标和终点坐标，设计一个回溯算法，编程判断起点能否到达终点，若能打印出路径。 输入数据： 有文件input。txt给出数据。第一行有1个正整数n（表示迷宫大小），第二行为路径；‘x’表示墙。 结果输出： 若能打印路径，否则打印nopath！ 输入文件示例： 输入： 4 00 33 。。。。 。。。。 x x x 。 。。。。 输出： 0 。。。 0 0 0 0 x x x 0 。。。x
用栈实现迷宫求解
weixin_33802505的博客
03-21 268
严书上迷宫问题求解，讲了栈的用途，可以存放过程数值。自己实现很有难度（好像图的深度遍历也行，有什么联系呢？）。 核心代码如下： 1 Status MazePath(PosType start, PosType end) 2 { 3 4 PosType curpos=start; 5 SqStack S; 6 SElemType e; 7...
迷宫问题的回溯法求解的c++实现
11-07
给出迷宫，求出所有路径. 通过递归实现。
labyrinth-java.rar_Java 数据结构_Java 迷宫_数据结构 java_迷宫 java_迷宫算法
09-23
这个项目可以帮助我们深入理解如何利用Java来处理和解决复杂的数据结构问题，特别是与迷宫相关的路径寻找算法。 首先，我们要了解什么是迷宫。迷宫是一种复杂的问题空间，通常由一系列相互连接的通道构成，具有起点...
数据结构-栈的应用-迷宫求解
04-16
在本主题“数据结构-栈的应用-迷宫求解”中，我们将探讨如何利用栈来解决迷宫路径搜索的问题。 首先，迷宫求解是一个典型的图遍历问题，可以通过深度优先搜索（DFS）或广度优先搜索（BFS）等算法来解决。在这里，...
《数据结构》-李春葆 实验报告-栈与队列的应用-求解迷宫路径问题
12-20
"数据结构-栈与队列的应用-求解迷宫路径问题" 在这篇实验报告中，我们主要讨论了栈和队列的应用在解决迷宫路径问题方面的实践。我们将详细介绍实验的设计人员相关信息、实验目的与要求、实验内容、实验步骤与过程等...
栈在迷宫求解问题中的应用.pdf
最新发布
03-16
在计算机科学中，栈是一种非常重要的数据结构，它遵循“后进先出”（LIFO）的原则。...通过这个实验，学生不仅能理解栈在解决实际问题中的作用，还能掌握迷宫求解算法的实现，增强对数据结构和算法的理解。
migongwenti.rar_migongwenti_site:www.pudn.com_数据结构 迷宫问题
09-24
总结来说，"migongwenti.rar" 是一个关于数据结构课程设计的项目，主要涉及迷宫问题的求解。通过VC++的编程实现，学生可以学习到如何运用数据结构和算法来解决实际问题，尤其是理解和应用搜索算法，这对提升编程技能...
栈的应用——迷宫问题的求解
weixin_30629653的博客
09-11 119
利用栈实现迷宫问题的求解（找到迷宫的通路，如下面给定的迷宫，0代表通路，1代表不通，利用栈的特点，求出他的通路） 给定的迷宫： 1 1 1 1 1 1 1 1 1 11 1 1 1 1 1 1 1 1 10 0 0 1 1 1 1 1 1 11 1 0 1 1 1 1 1 1 11 1 0 1 1 1 1 1 1 11 1 0 1 1 1 1 1 1 11 1 0 0 0 0 0 0 1 11...
数据结构02 栈的迷宫求解问题实现
weixin_30873847的博客
10-31 95
约定： 通过数组形式表示迷宫。 用1表示不通，0表示通路。 方向变量：1表示东，2表示南，3表示西，4表示北。 将入口坐标作为当前位置，按顺时针探索入口的四个附近方向值。 如果当前位置值为0： 如果附近的其中一个方向值为0，表示可以通过，则方向变量为该方向代表的值。将当前位置的值改为2表示已经经过。将当前位置压栈，将当前位置移动到可以通过的位置。具体通过横纵坐标的加减一来实现。如果附近...
栈的应用——迷宫求解
Mongo_girl
01-28 381
do｛        若当前位置可通，     则｛         将当前位置插入栈顶；          若该位置是出口位置，则算法结束；                     否则切换当前位置的东邻方块为新的当前位置；     ｝     否则 {            若栈不空且栈顶位置尚有其他方向未被探索，             则设定新的当前位置为: 沿顺时针方向旋转找到的栈顶位置...
数据结构应用回顾之Stack(二) 迷宫问题
专注互联网技术
04-14 156
  迷宫问题，一般采用回溯法，利用stack节点探测，算法复杂度O(n^2)，好像采用队列也可以实现，下片日志再使用队列试试。   package com.xx.dataStructure.stack; enum Direction { east, south, west, north, nothing } class Position { int x; int...
数据结构总结4——栈——迷宫问题的实现 by DexterYan
qq_41259302的博客
05-24 291
一、基础知识 二、代码实现 #include<stdio.h> #include<stdlib.h> #define SIZE 7 #define MAXSIZE 1024 /*int Maze[SIZE][SIZE]={ {1,1,1,1,1,1,1}, {1,0,0,1,0,0,1}, {1,0,0,1,0,1,1}, {1,0,0,0,0,0,1}, {1,...
数据结构之图论：迷宫探索（顺序，逆序保存路径）
ZangWhe
04-04 438
今天刷的第二道水题dfs了,希望能慢慢理解dfs，bfs的精髓！！ 数据结构实验之图论四：迷宫探索 Time Limit:1000 msMemory Limit:65536 KiB SubmitStatistic Problem Description 有一个地下迷宫，它的通道都是直的，而通道所有交叉点(包括通道的端点)上都有一盏灯和一个开关；请问如何从某个起点开始在迷宫中点亮所...
数据结构例题--迷宫
chihiro1122的博客
11-09 4642
迷宫oj题的思路代码实现
栈：迷宫问题（多组矩阵）
weixin_58707952的博客
11-14 92
#include<iostream> #include<stack> #include<vector> using namespace std; typedef struct Direction { int intcx, intcy; }; Direction direction[4] = { {0,1},{1,0},{0,-1},{-1,0} };//分别表示右、下、左、上四个方向 typedef struct Node { int x; int y; in.
利用栈求解迷宫 --数据结构实验
xueba8的博客
10-28 3948
一、实验目的 1、了解回溯法在求解迷宫问题中的应用 2、进一步掌握栈的使用 二、实验内容 用回溯法求解迷宫问题，可以用一个栈保存探索的序列。并且在该迷宫的行走中，站在一点可以有八个方向选择。 比如如下的迷宫 Enter-> 0   1   1   1   0   0   0   0   0   0 0   0   0   1   0   0   0   1   0   0 0   
数据结构课件：栈与队列在迷宫路径求解中的应用
理解栈和队列的概念以及它们的工作原理对于学习数据结构和算法至关重要，因为它们在许多实际问题中都有着广泛的应用。无论是软件开发、操作系统设计还是算法设计，掌握栈和队列都能帮助我们更有效地解决问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值