栈的应用——迷宫

最新推荐文章于 2023-06-11 20:30:47 发布
最新推荐文章于 2023-06-11 20:30:47 发布
阅读量169 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wm12345645/article/details/80019450
版权

本文共总结三个方法：

1，  迷宫不带环（循环法）2，迷宫不带环（递归法）3，迷宫带环（递归法）

 

 

一，迷宫不带环（循环法）的基本思路：

  通过栈来保存路径，首先将初始位置入栈，后用取出栈顶元素的方式，得到初始位置，

  然后进入while循环，循环内有4种情况，找到出口，向四个方向走动，走错了，找              

  不到出口（栈空了）。

 

  若可以向四个方向走通，则将next位置入栈，并用continue返回到循环初始语句，

  我们为可以走通的位置赋值2，以标记路径，一直走会找到出口，出循环，结束程序

  或者走错了

 

  为走错的位置赋值3，以表示此路不通，并出栈当前位置，回到循环头，一直出栈会       　使栈空而退出，或者找到可以走通的位置

 

     

  循环会在找到出口或栈空了的时候退出，除循环后需判断是那种原因退出

 

头文件

#ifndef __MAZE_H__
#define __MAZE_H__

//#pragma once

#include"StackD.h"

#define MAX_ROW 6
#define MAX_LOW 6

typedef struct Maze
{
  int _map [MAX_ROW][MAX_LOW];
}Maze;



//初始化 迷宫
void InitMaze(Maze* m  );

//打印迷宫
void PrintMaze(Maze*m);



//判断入口是否有效
int IsValidEnter(Maze*m,Position enter);

//判断当前这步能否走通
int IsPass(Maze * m,Position cur);

//走迷宫(循环法)
void PassMazeNor(Maze* m,Position enter ,StackD *s);

//判断出口
int IsMazeExit(Maze* m,Position cur,Position enter);


#endif //__MAZE_H__

 

函数文件

//#include"Maze.h"
//
//void InitMaze(Maze* m)
//{
//	int map[MAX_ROW][MAX_LOW]={
//		{0,0,0,0,0,0},
//		{0,0,1,0,0,0},
//		{0,0,1,0,0,0},
//		{0,0,1,1,1,0},
//		{0,0,1,0,1,1},
//		{0,0,1,0,0,0}
//	};
//	
//	int i=0;
//	int j=0;
//    assert(m);
//	for(;i<MAX_ROW;i++)
//	{
//		j=0;
//	  for(;j<MAX_LOW;j++)
//	  {
//		  m->_map[i][j]=map[i][j];
//	  }
//	}
//}
//
//void PrintMaze(Maze*m)
//{
//    int i=0;
//	int j=0;
//    assert(m);
//	for(;i<MAX_ROW;i++)
//	{
//		j=0;
//	  for(;j<MAX_LOW;j++)
//	  {
//		  printf("%d ",m->_map[i][j]);
//	  }
//	  printf("\n");
//	}
//}
//
判断入口是否有效
//int IsValidEnter(Maze*m,Position enter)
//{  
//   assert(m);
//   if(1==m->_map[enter._x][enter._y])
//   {
//     return 1;
//   }
//   return 0;
//}
//
//
判断当前这步能否走通
//int IsPass(Maze * m,Position cur)
//{
//  assert(m);越界问题
//  处理
//  if(1==m->_map[cur._x][cur._y]&&((cur._x<=MAX_ROW-1)&&(cur._x>=0)&&(cur._y<=MAX_LOW-1)&&(cur._y>=0)))
//  {
//     return 1;
//  }
//  return 0;
//}
//
判断出口
//int IsMazeExit(Maze* m,Position cur,Position enter)
//{
//	if((cur._x==enter._x)&&(cur._y==enter._y))
//	{
//	 return 0;
//	}
//	if(0==cur._x||0==cur._y||MAX_ROW-1==cur._x||MAX_LOW-1==cur._y)
//	{
//	  return 1;
//	}
//	return 0;
//}
//
//
走迷宫
//void PassMazeNor(Maze* m,Position enter ,StackD *s)
//{
//	Position cur;
//	Position next;
//  assert(m);
//  
//  //判断入口是否有效
//  if(1!=IsValidEnter(m,enter))
//  {
//    printf("无效入口！\n");
//	return ;
//  }
//  m->_map[enter._x][enter._y]=2;
//  // 入栈 
//  StackDPush(s,  enter);
//  while(StackDEmpty(s))//将出口也出栈时，栈内为空，越界问题以处理
//  {
//
//	 
//	  
//	   cur=StackDTop(s);
//		m->_map[cur._x][cur._y]=2;
//	    //判断是否找到出口
//	   if(IsMazeExit(m,cur,enter))
//	   {
//	     break;
//	   }
//	  
//	   
//    //上
//		next=cur;
//		next._x-=1;
//		if(IsPass(m,next))//判断向上能否走通
//		{
//		   // 入栈 
//		StackDPush(s, next);
//		continue;
//		}
//    //左
//		next=cur;
//		next._y-=1;
//		if(IsPass(m,next))//判断向左能否走通
//		{
//		   // 入栈 
//		StackDPush(s, next);
//		continue;
//		}
//    //右
//		next=cur;
//		next._y+=1;
//		if(IsPass(m,next))//判断向右能否走通
//		{
//		   // 入栈 
//		StackDPush(s, next);
//		continue;
//		}
//	//下
//		next=cur;
//		next._x+=1;
//		if(IsPass(m,next))//判断向下能否走通
//		
//		   // 入栈 
//			{
//			StackDPush(s, next);
//		    continue;
//			}
//	
//    //走错了
//
//		m->_map[cur._x][cur._y]=3;
//		// 出栈 
//		 StackDPop(s); 
//  }
//		//出循环的两种可能
//		//1，判断栈为空
//		if(!StackDEmpty(s))
//		{
//		  printf("迷宫没有出口！\n");
//		  return ;
//		}
//		//2,找到出口退出
//		printf("出口为%d ，%d",cur._x,cur._y);
//
//}

 

测试文件

//#include"Maze.h"
//
//
//Maze m;
//StackD s;
//
//
// 
//void TestMaze()
//{
//	Position enter;
//	
//	
//	enter._x=5;
//	enter._y=2;
//	StackDInit(&s);
//   InitMaze(&m);
//   PrintMaze(&m);
//   PassMaze(&m,enter );
//   PrintMaze(&m);
//}
//int main ()
//{
//	TestMaze();
//  return 0;
//}

 

二，迷宫不带环（递归法）的基本思路

　递归函数内有３种情况，找到出口，向四个方向走动，走错了。

　if(_PassMaze(m,enter,next))

         {

           return 1;

         }

　找到出口_PassMaze返回１，则if(_PassMaze(m,enter,next))条件成立，则所有_PassMaze函数返回，程序结束

　走错了返回０，if(_PassMaze(m,enter,next))条件不成立，当前函数不返回，测试下一个方向，测完所有方向发现走错了，　 返回上级函数，重复动作，直到找到出口返回，或发现没有出口返回　

　

头文件

#ifndef __MAZE_H__
#define __MAZE_H__

//#pragma once

#include"StackD.h"

#define MAX_ROW 6
#define MAX_LOW 6

typedef struct Maze
{
  int _map [MAX_ROW][MAX_LOW];
}Maze;



//初始化 迷宫
void InitMaze(Maze* m  );

//打印迷宫
void PrintMaze(Maze*m);



//判断入口是否有效
int IsValidEnter(Maze*m,Position enter);

//判断当前这步能否走通
int IsPass(Maze * m,Position cur);



//判断出口
int IsMazeExit(Maze* m,Position cur,Position enter);
//递归法
void PassMaze(Maze* m,Position enter);
//递归体
int  _PassMaze(Maze*m,Position enter,Position cur);

#endif //__MAZE_H__

 

函数文件

#include"Maze.h"

void InitMaze(Maze* m)
{
	int map[MAX_ROW][MAX_LOW]={
		{0,0,0,0,0,0},
		{0,0,1,0,0,0},
		{0,0,1,0,0,0},
		{0,0,1,1,1,0},
		{0,0,1,0,1,1},
		{0,0,1,0,0,0}
	};
	
	int i=0;
	int j=0;
    assert(m);
	for(;i<MAX_ROW;i++)
	{
		j=0;
	  for(;j<MAX_LOW;j++)
	  {
		  m->_map[i][j]=map[i][j];
	  }
	}
}

void PrintMaze(Maze*m)
{
    int i=0;
	int j=0;
    assert(m);
	for(;i<MAX_ROW;i++)
	{
		j=0;
	  for(;j<MAX_LOW;j++)
	  {
		  printf("%d ",m->_map[i][j]);
	  }
	  printf("\n");
	}
}

判断入口是否有效
int IsValidEnter(Maze*m,Position enter)
{  
   assert(m);
   if(1==m->_map[enter._x][enter._y])
   {
     return 1;
   }
   return 0;
}


判断当前这步能否走通
int IsPass(Maze * m,Position cur)
{
  assert(m);越界问题
  处理
  if(1==m->_map[cur._x][cur._y]&&((cur._x<=MAX_ROW-1)&&(cur._x>=0)&&(cur._y<=MAX_LOW-1)&&(cur._y>=0)))
  {
     return 1;
  }
  return 0;
}

判断出口
int IsMazeExit(Maze* m,Position cur,Position enter)
{
	if((cur._x==enter._x)&&(cur._y==enter._y))
	{
	 return 0;
	}
	if(0==cur._x||0==cur._y||MAX_ROW-1==cur._x||MAX_LOW-1==cur._y)
	{
	  return 1;
	}
	return 0;
}



递归法
void PassMaze(Maze* m,Position enter)
{
  assert(m);
  
  判断入口是否有效
  if(1!=IsValidEnter(m,enter))
  {
    printf("无效入口！\n");
	return ;
  }
  _PassMaze(m,enter,enter);
}
递归体
int  _PassMaze(Maze*m,Position enter,Position cur)
{
	Position next;
   if(IsPass(m,cur))//是不是通路
   {
		 m->_map[cur._x][cur._y]=2;
     if(IsMazeExit(m,cur,enter))//是不是出口
	   {
		   //找到出口退出
		printf("出口为%d ，%d",cur._x,cur._y);

	     return 1;
	   }
	 //上
		next=cur;
		next._x-=1;
		if(_PassMaze(m,enter,next))
		{
		  return 1;
		}

		
	 //左
		next=cur;
		next._y-=1;
		if(_PassMaze(m,enter,next))
		{
		  return 1;
		}
	 //右
		next=cur;
		next._y+=1;
		if(_PassMaze(m,enter,next))
		{
		  return 1;
		}
	 //下
		next=cur;
		next._x+=1;
		if(_PassMaze(m,enter,next))
		{
		  return 1;
		}
		m->_map[cur._x][cur._y]=3;
	}
		return 0;
}

 

测试文件

//#include"Maze.h"
//
//
//Maze m;
//StackD s;
//
//
// 
//void TestMaze()
//{
//	Position enter;
//	
//	
//	enter._x=5;
//	enter._y=2;
//	StackDInit(&s);
//   InitMaze(&m);
//   PrintMaze(&m);
//   PassMaze(&m,enter );
//   PrintMaze(&m);
//}
//int main ()
//{
//	TestMaze();
//  return 0;
//}

 

 

三，迷宫带环（递归）

定义两个栈，path用来记录路径，shortpath用来记录最短路径

所谓更新栈，就是在shortpath为空，或者path的size小于shortpath的size时，将path的内容放入shortpath中

递归函数内有３种情况，找到出口，向四个方向走动，走错了。

 

找到出口了，更新栈，出栈入口 ，返回上级函数，继续测试其他方向，可能找到新的出口，更　　

新栈，可能找不到而逐级退出

头文件

#ifndef  __LOOP_MAZE__
#define  __LOOP_MAZE__

#include"StackD.h"
#include<stdio.h>
#include<assert.h>


#pragma once



#define MAX_ROW 6
#define MAX_LOW 6

typedef struct Maze
{
  int _map [MAX_ROW][MAX_LOW];
}Maze;



//初始化 迷宫
void InitMaze(Maze* m  );

//打印迷宫
void PrintMaze(Maze*m);



//判断入口是否有效
int IsValidEnter(Maze*m,Position enter);

//判断当前这步能否走通
int _IsPass(Maze * m,Position next,Position cur);

//走迷宫(循环法)
void PassMazeNor(Maze* m,Position enter ,StackD *s);

//判断出口
int IsMazeExit(Maze* m,Position cur,Position enter);
//递归法
void PassMaze(Maze* m,Position enter,StackD* path,StackD*shortpath);
//递归体
void  _PassMaze(Maze*m,Position enter,Position cur,StackD* path,StackD*shortpath);



#endif //__LOOP_MAZE__

 

函数文件

#include"LoopMaze.h"

void InitMaze(Maze* m)
{
	int map[MAX_ROW][MAX_LOW]={
		{0,0,0,0,0,0},
		{0,1,1,1,0,0},
		{0,1,0,1,0,0},
		{0,1,0,1,0,0},
		{0,1,1,1,1,1},
		{0,1,0,0,0,0}
	};
	
	int i=0;
	int j=0;
    assert(m);
	for(;i<MAX_ROW;i++)
	{
		j=0;
	  for(;j<MAX_LOW;j++)
	  {
		  m->_map[i][j]=map[i][j];
	  }
	}
}

void StackDPrint(StackD* s)
{
	int i=0;
	assert(s);
	
	if(0==s->size)
	{
		printf("no yuansu!\n");
	  return ;
	}
	for(;i<s->size;i++)
	{
		printf("(%d,%d)-->",(s->array)[i]._x,(s->array)[i]._y);

	}
}

void PrintMaze(Maze*m)
{
    int i=0;
	int j=0;
    assert(m);
	for(;i<MAX_ROW;i++)
	{
		j=0;
	  for(;j<MAX_LOW;j++)
	  {
		  printf("%d ",m->_map[i][j]);
	  }
	  printf("\n");
	}
}



//判断出口
int IsMazeExit(Maze* m,Position cur,Position enter)
{
	if((cur._x==enter._x)&&(cur._y==enter._y))
	{
	 return 0;
	}
	if(0==cur._x||0==cur._y||MAX_ROW-1==cur._x||MAX_LOW-1==cur._y)
	{
	  return 1;
	}
	return 0;
}

//判断入口是否有效
int IsValidEnter(Maze*m,Position enter)
{  
   assert(m);
   if(1==m->_map[enter._x][enter._y])
   {
     return 0;
   }
   return 1;
}



//判断当前这步能否走通
//两个条件  不越界 等于1或者大于之前元素
int _IsPass(Maze * m,Position next,Position cur)
{
  assert(m);
  if(((1==m->_map[next._x][next._y])||((m->_map[cur._x][cur._y])<(m->_map[next._x][next._y])))&&
	  ((next._x<=MAX_ROW-1)&&(next._x>=0)&&(next._y<=MAX_LOW-1)&&(next._y>=0)))
  {
    return 1;
  }
  return 0;
}


//更新栈
 void Saveshortpath(StackD* shortpath,StackD* path)
 {
	 Position ret1;
	 Position ret;

	 int size=0;
	 int i=0;
   assert(shortpath);
   assert(path);
   shortpath->size=0;
   size=path->size;
   while(size)
   {
     StackDPush(shortpath ,path->array[i]);
	 ret= StackDTop(path);
	 ret1= StackDTop(shortpath);

     size--;
	 i++;
   }

 }
//递归体
void  _PassMaze(Maze*m,Position enter,Position cur,StackD* path,StackD*shortpath)
{
	Position next;
	//入口要特殊赋值
	if(!StackDEmpty(path))
	{
	  m->_map[cur._x][cur._y]=2;
	}
	//入栈
	StackDPush(path,cur);
	//情况1：遇到出口 更新栈 并返回
		  if(IsMazeExit(m,cur,enter))
		  {
			//更新栈
			  if(!StackDEmpty(shortpath)||StackDSize(path)<StackDSize(shortpath))
			  {
				  //如果最短路径栈为空，或储存栈比最短路径栈小，则更新小栈
				  Saveshortpath(shortpath,path);
			  }
			  StackDPop(path);
			return;
		  }

    //情况2：向上走通
		  next=cur;
          next._x-=1;
		  //在外面给下一个点赋值（+1）
		 

		  if(_IsPass(m,next,cur))//两个条件  等于1或者大于前一个   不出界
		  {
		    m->_map[next._x][next._y]=m->_map[cur._x][cur._y]+1;
			
			_PassMaze(m,enter,next,path,shortpath);
		  }

      
    //情况3：向左走通
		  next=cur;
          next._y-=1;
		  //在外面给下一个点赋值（+1）
		 

		  if(_IsPass(m,next,cur))//两个条件  等于1或者大于前一个   不出界
		  {
		    m->_map[next._x][next._y]=m->_map[cur._x][cur._y]+1;
			
			_PassMaze(m,enter,next,path,shortpath);
		  }

     
    //情况4：向右走通
		  next=cur;
          next._y+=1;
		 
		 

		  if(_IsPass(m,next,cur))//两个条件  等于1或者大于前一个   不出界
		  {

			//因为必须要先判断是否越界 所以在里面给下一个点赋值（+1）
		    m->_map[next._x][next._y]=m->_map[cur._x][cur._y]+1;
			
			_PassMaze(m,enter,next,path,shortpath);
		  }
    
    //情况5：向下走通
		  next=cur;
          next._x+=1;
		  //在外面给下一个点赋值（+1）
		 

		  if(_IsPass(m,next,cur))//两个条件  等于1或者大于前一个   不出界
		  {
		    m->_map[next._x][next._y]=m->_map[cur._x][cur._y]+1;
			
			_PassMaze(m,enter,next,path,shortpath);
		  }

	//情况6 ：走到此处表示走错了  直接出栈此元素
		  StackDPop(path);



}

//递归法
void PassMaze(Maze* m,Position enter,StackD* path,StackD*shortpath)
{
  //判断入口
	if(IsValidEnter(m,enter))
	{
	  return ;
	}
		_PassMaze(m,enter,enter,path,shortpath);
     
}

 

测试文件

#include"LoopMaze.h"

StackD path;
StackD shortpath;
Maze m;

Position ret;

  
void TestLoop()
{
    Position enter;
	

	
	
	enter._x=5;
	enter._y=1;
  StackDInit( &path); 
  StackDInit( &shortpath); 

  InitMaze(&m);
    
  PassMaze(&m, enter,&path,&shortpath);

  PrintMaze(&m);

  StackDPrint( &shortpath);


}
int main ()
{
	TestLoop();
  return 0;
}

 


wm12345645
关注
栈的应用_迷宫求解
孟凡驰的博客
03-22 1763
标题： 迷宫问题 时 限： 100000 ms 内存限制： 100000 K 总时限： 3000 ms 描述： 迷宫问题 迷宫是一个二维矩阵,其中1为墙,0为路,3为入口,4为出口.要求从入口开始,从出口结束,按照 下,左,上,右 的顺序来搜索路径. 输入： 迷宫宽度w 迷宫高度h 迷宫第一行 迷宫第二行 ...
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 栈 —— 应用 —— 迷宫老鼠
coding-hwz
08-15 563
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 栈 —— 应用 —— 迷宫老鼠一、问题描述二、设计1、类图三级目录 一、问题描述 迷宫是一个矩形区域，有一个入口和一个出口。迷宫内部包含不能穿越的墙壁或障碍物。这些障碍物沿着行和列防止，与迷宫的边界平行。迷宫的如果在左上角，出口在右下角。 我们可以使用一个 bool 矩阵来描述这个迷宫。当矩阵中某个位置有障碍时，其值为 ture，否则为 false。迷宫老鼠问题是要寻找一条从入口到出口的路径。路径是一个由位置组成的序列。每一个位置都没有障碍，而且
栈的应用--迷宫问题
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代表空格（可通过）代码中每一步有详细注释。欢迎大家交流，嘻嘻。
栈的应用——迷宫问题
Android茶话会
10-10 1376
这里结合了栈+深度优先算法
栈的应用-迷宫解题
xuerenlv的专栏
05-20 757
/* 二. 栈的应用-迷宫解题 */ #include #include #include #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 //坐标类型 typedef
栈的应用 —— 迷宫问题
热门推荐
一枚野生程序员 —— Tim
08-17 3万+
题目 这是几个由二维数组构成的迷宫，简单的迷宫，多通路不带环的迷宫，多通路带环的迷宫！对于简单迷宫我们需要判断是否有出口！对于多通路不带环的迷宫我们需要确定出口并且判断最短路径，对于通路间带环的迷宫我们需要找出最短路径！ 算法思想：回溯 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜...
migong.rar_migong_数据结构 迷宫_栈的应用_迷宫 栈_迷宫问题
09-23
栈是数据结构的一种，具有“后进先出”（LIFO）的特性，广泛应用于各种问题的解决，包括我们今天要讨论的主题——迷宫问题。 标题中的“migong.rar_migong_数据结构 迷宫_栈的应用_迷宫 栈_迷宫问题”暗示了这是一...
《数据结构》— 栈的应用——迷宫求解问题
69小石头的博客
12-03 1325
/* 利用栈求解迷宫问题（只输出一个解，算法3.3） */ typedef struct /* 迷宫坐标位置类型 */ { int x; /* 行值 */ int y; /* 列值 */ }PosType; #define MAXLENGTH 25 /* 设迷宫的最大行列为25 */ typedef int MazeType[MAXLENGTH][MAXLENGTH]...
栈的应用之迷宫问题
legend050709的专栏
06-05 721
/************************************************************************/ /*自定义栈                                                                         */ /*通过自定义的简单栈以满足迷宫求解                */ /*功
栈的应用——迷宫求解问题
weixin_52771283的博客
04-11 2998
之前发过的一篇文章也是关于栈的应用 https://blog.csdn.net/weixin_52771283/article/details/115506606 这是利用栈“后进先出”的特点实现有优先级的加减乘除四则运算。 想在这里介绍另外一个栈的应用的典型例子——迷宫求解。 首先说一下基本问题： 迷宫的表示 在写代码的时候我们可以用一个二维数组 int map[10][10] 表示一个8x8大小的迷宫（由于需要在迷宫的最外层加上一堵“墙”，定义数组的时侯行数和列数分别+2），并通过对数组的元素 ma
栈的应用：迷宫问题(DFS,非递归)
m0_63223213的博客
07-04 1785
DFS迷宫问题超详解~
栈的应用之迷宫求解（C语言附完整代码）
m0_62795460的博客
04-11 1万+
若一个非出口方块 ( i , j )是可走的，将它进栈，每个刚刚进栈的方块：其方位di置为-1(表示尚未试探它的周围)，然后开始从方位0到方位3试探这个栈顶方块的四周，如果找到某个方位d的相邻方块(i1，j1）是可走的，则将栈顶方块(i,j）的方位di置为d，同时将方块（i1，j1)进栈，再继续从方块(i1，j1)做相同的操作。也就是说，从方块( i , j )出发会试探方块 ( i+1 , j ） ,而从方块( i+1, j ) 出发又会试探方块( i , j ），这样可能会引起死循环，
数据结构学习——栈的应用：迷宫问题
最新发布
weixin_73899513的博客
06-11 677
在函数findPath内，我写了一个包裹类，dirPoint,它有三个成员，x（行坐标），y（列坐标），dir（下一步要搜索的方向：0：上，1：下，2：左，3：右），用一个该类的栈进行深度优先搜索。当弹出的一个点dir == 4时，表示四个方向已经探测完毕，此路必然不通，则continue，进入下一轮循环时，弹出的点必然是路径的上一个点，如果还有别的方向，则尝试该方向，如果仍然dir == 4，表示这个点也走进了死胡同。初始时先将起点进栈，并将dir设为0，表示下一步要搜索的方向为上方。
数据结构：栈与队列之迷宫（详解）
study_jiang_up的博客
11-18 4204
迷宫对于数据结构的萌新来说，是比较困难的。所以需要多理解栈和队列的思想，在看这个之前，可以先做做栈和队列其他题目，比如转进制转化等问题，再回来写迷宫问题会更好理解。
用栈来实现迷宫
zimituanzi_的博客
06-11 3162
迷宫 下面先简单的介绍一下迷宫，我们给出的迷宫实际上是一个二维数组，在二维数组中1表示可以走通，0表示走不通，如下图所示给一个简单的迷宫： 实现代码： maze.h文件 // 用递归的方式求解简单迷宫问题 #define MAX_ROW 5 #define MAX_COL 5 #include "Stack.h" typedef struct Maze { int ...
用栈和队列求解迷宫问题
斗锋在干嘛的博客
12-26 7775
1：①、定义一个顺序栈；     ②、编写走出迷宫代码；     ③、编写主函数。 1、栈： #include #include #include #include #define MaxSize 100 //①、定义一个顺序栈； typedef struct { int i; int j; int di; } Box; typedef stru
数据结构-走迷宫问题（栈的运用）
qq_40251838的博客
06-02 5562
用矩阵代表地图，矩阵中1代表可以走通，0代表可以走通。假设目前位于（x,y）处，则下一可走位置为（）
栈解决迷宫问题
yifangfeii的博客
10-27 1308
这种解决思路类似DFS，从起点开始向前走，每走一步，就向四周探寻可走方向，如果找到一个可走方向，首先“保存现场”（将走向的是哪一个方向保存下来），再向找到的方向走一步，重复上述过程。同时对走过的路上做一个标记，防止形成死循环。 如果发现走到了死胡同，四周都无路可走，则回退到上一步，“恢复现场”（从保存的方向开始，看下一个方向是否可走），如果还是死胡同，再回退。若回退到起点（栈已经pop到没有元素了），则无解。 如果走着走着发现走到了终点，则找到了迷宫的一个解，此时将栈内元素依次出栈，并存储到一个数组内，再逆
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值