数据结构迷宫问题的求解算法,迷宫最短路径算法
这个稍微比迷宫一问题要难了一点，但是大致都是差不多的，只是需要小小的改动一下
这里主要介绍它的注意点：
有多条路但是要找到它的最小路径，还是一样的采用深度优先遍历，递归来实现
1、如果是通道，那是不是走过了就要标记，但是我们找的是最小路径是不是就需要回溯，回溯时就要把标记改为通道1,以防下次就走不通了
2、区分深度拷贝和浅拷贝，代码里也有介绍，最小路径=路径浅拷贝，指向了同一块内存空间，当小路的内容改变最小路径也会改变；深度拷贝，路径和最小路径各占不一样的存储空间，不会互相影响最好结合代码看
上代码：
#define _CRT_SECURE_NO_WARNINGS
#包含标准视频
#包含标准库
#include assert.h
#包含标准布尔
#包含字符串。h
数据类型说明结构路径
{
（同Internationalorganizations）国际组织行；
内部列
}拍拍；
/*///////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
typedef PAT标准数据类型
数据类型说明结构堆栈
{
stdata类型* a；
int top//指向栈顶就是大小
（同Internationalorganizations）国际组织容量；//容量
} ST
void堆栈初始化(ST * PS)；//初始化
无效堆叠打印(const ST * PS)；//打印
void StackPush(ST* ps，stdata type x)；//入栈
无效堆栈销毁(ST * PS)；//销毁
空的堆栈弹出(ST * PS)；//出栈
stdata类型栈顶(const ST * PS)；//取栈顶
int堆栈大小(const ST * PS)；//计算栈的元素
//bool StackEmpty(const ST* ps，int * size)；
bool StackEmpty(const ST * PS)；//判断栈是否为空
无效堆栈单位(ST* ps)
{
assert(PS)；
PS-a=NULL；
ps-容量=0;
PS-top=0；//也可以给-1
}
//void StackPrint(const ST* ps)
//{
//assert(PS)；
//int I；
//for(I=PS-top-1；我我-)
//{
//printf(%d ，PS-a[I])；
//}
//printf( \ n )；
//}
无效新堆栈(ST* ps)
{
int newcapacity=ps- capacity==0？4 : ps-容量* 2;
ST* newStack=realloc(ps- a，sizeof(ST)*新容量)；
if (newStack==NULL)
{
printf(开辟内存失败);
退出(-1);
}
PS-a=新堆栈；
PS-容量=新容量；
}
void StackPush(ST* ps，STDataType x)
{
assert(PS)；
如果(ps容量==ps顶部)
{
新栈(PS)；
}
PS-a[PS-top]=x；
PS-top；
}
无效堆栈弹出(ST* ps)
{
assert(PS)；
断言(ps- top
如果(ps- top 0)
PS-top-；
}
STDataType StackTop(const ST* ps)
{
assert(PS)；
断言(ps- top
返回PS-a[PS-top-1]；
}
int StackSize(const ST* ps)
{
assert(PS)；
返回ps-
}
布尔堆栈
{
return PS-top==0；
}
无效堆栈销毁(ST* ps)
{
assert(PS)；
free(PS-PS-a=NULL；
PS-capacity=PS-top=0；
}
斯托克斯路径；//设置全局栈
圣明帕斯
void StackCopy(ST* path，ST* pcopy)
{
pcopy-a=(stdata type *)malloc(sizeof(stdata type/* stdata type * */)* path-capacity)；
memcpy(pcopy- a，path- a，sizeof(stdata type)* path-top)；
pcopy- top=path-
pcopy-capacity=path-capacity；
}
/*///////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
//输出路径坐标
无效打印路径(ST*路径)
{
圣rPath
堆栈初始化(rPath)；
而(!堆栈式(路径))
{
StackPush( rPath，stack top(path))；
堆栈弹出(路径);
}
while (StackSize( rPath) 1)
{
PAT top=栈顶(rPath)；
printf([%d，%d]，，top.row，top。col)；
堆栈弹出(rPath)；
}
PAT top=栈顶(rPath)；
printf([%d，%d]，top.row，top。col)；
堆栈弹出(rPath)；
堆栈销毁(rPath)；
}
void Print(int** maze，int n，int m)
{
for(int I=0；我我)
{
for(int j=0；j j)
{
printf( %d ，maze[I][j])；//输入二维数组的值
}
printf( \ n )；
}
printf( \ n )；
}
bool IsPass(int** maze，int n，int m，PAT cur)
{
如果(当前行=0当前行n
当前列=0当前列m
迷宫[当前行][当前列]==1)
{
返回真实的
}
其他
返回错误的
}
void GetMazePath(int** maze，int n，int m，PAT cur，int p)
{
StackPush( path，cur)；//先入栈
if (cur.row==0 cur.col==m - 1)
{
//当最小路径为空就把小路的路径深度拷贝到最小路径中
//当path找到比minpath短的路径时，将path的路径深度复制到minpath中。
if (p=0 StackEmpty( minpath)
stack size(path)stack size(minpath))
{
stack destroy(min path)；//释放原来的minpath，避免内存泄漏。
///minpath=path路径的浅拷贝，指向同一个内存空间。当path的内容发生变化时，minpath也会发生变化。
//深度复制，path和minpath占用不同的存储空间，不会互相影响。
StackCopy( path，minpath)；
}
}
迷宫[当前行][当前列]=2；
//去
拍拍下；
next=cur
next . row-=1；
if (IsPass(maze，n，m，next))
{
GetMazePath(迷宫，n，m，next，p-3)；//向上移动一个单位需要3个体力值
}
//向下
next=cur
next . row=1；
if (IsPass(maze，n，m，next))
{
GetMazePath(迷宫，n，m，next，p)；//不要把体力消耗下来。
}
//左侧
next=cur
next . col-=1；
if (IsPass(maze，n，m，next))
{
GetMazePath(迷宫，n，m，next，p-1)；//水平移动一个单位消耗一个体力值
}
//右
next=cur
next . col=1；
if (IsPass(maze，n，m，next))
{
GetMazePath(迷宫，n，m，next，p-1)；//水平移动一个单位消耗一个体力值
}
迷宫[当前行][当前列]=1；//返回并恢复公共路径。
StackPop(路径)；//如果以上条件都不满足，则弹出堆栈
}
int main()
{
int n=0，m=0，p=0；//p是指体力值的水平移动，一个单位消耗一个体力值，一个单位消耗三个体力值，向下移动不消耗体力值。
scanf(%d，%d，%d ，n，m，
//创建2D数组的一行
int * * maze=(int * *)malloc(sizeof(int *)* n)；
for(int I=0；我我)
{
//创建一个二维数组的列
maze[I]=(int *)malloc(sizeof(int)* m)；
}
for(int I=0；我我)
{
for(int j=0；j j)
{
scanf(%d ，maze[I][j])；//输入二维数组的值
}
}
StackInit(路径)；//初始化堆栈
stack init(minpath)；//初始化堆栈
PAT in path={ 0.0 }；
GetMazePath(迷宫，n，m，InPath，p)；
如果(！StackEmpty( minpath))
{
Print(迷宫，n，m)；
print path(minpath)；
}
其他
{
Printf (\ nEscape失败！);
}
StackDestroy(路径)；
stack destroy(min path)；
for(int I=0；我我)
{
免费(迷宫[I])；
}
自由(迷宫)；
迷宫=空；
}
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。