迷宫路径搜索问题(栈的链表实现)

这一次我们来学习下迷宫的的路径问题,用栈的链表形式实现。其实这个是属于一本书上的案例,看完了之后,按照自己的理解尝试做了下(ps:其实绝大大部分都是书上的代码)注释 。如果你发现了其中的错误,欢迎指出。

下面来说下思路:首先定义一个结构体:

struct TestStack

{

         int i;

         int j;

         int dir;//用来控制当前方向的走向,1时向左;2时向右;3时向上;4时向下;

}stack[50];//用来保存走到哪一步,进行回溯

 

Ij用来保存当前元素的下表,通过进栈和进栈来实现地图的回溯,stack数组用来表示步数的存储,通过stack[top].i可以访问存在在栈顶的xstack[top].j可以访问存在栈顶的y,通过x,y坐标就可以通过map数组访问数组值,如果路可以走,则进栈。dir是用来保存存储的方向,可以用来当这次的搜索路不通时,通过实现dir++ 可以搜索另外一个方向。

好了,下面就是全部代码:

// 迷宫问题().cpp : 定义控制台应用程序的入口点。

//

 

#include “stdafx.h”

 

struct TestStack

{

         int i;

         int j;

         int dir;//用来控制当前方向的走向,1时向左;2时向右;3时向上;4时向下;

}stack[50];//用来保存走到哪一步,进行回溯

 

int map[10][10] = //0表示有路可走,1表示此路不通,2表示点已被访问过

         {

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

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

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

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

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

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

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

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

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

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

 

         };

 

void Search(int resource_i,int resource_j,int distinct_i,int distinct_j)

{

         //TestStack *test = new TestStack;

         bool isFind  = false;//是否在当前位置上有路可走

         int top = 0;

         int n = 0;//用来控制搜索方向

         int di,dj;//用来保存当前元素的下标

         int dir = 0;

         stack[top].i = resource_i;

         stack[top].j = resource_j;//将起点进栈

 

        

         while( top >= 0)//当栈顶不为空时

         {

                   di = stack[top].i;

                   dj = stack[top].j;//当前所在元素的下表位置

                   dir = stack[top].dir;

                   //cout<<di<<”  “<<dj<<endl;

                   if(di == distinct_i && dj == distinct_j)//如果找到了到达终点的路,路径搜索完成

                   {

                            cout<<“路径如下所示:”<<endl;

                            for (int m = 0; m <= top; m++)

                            {

                                     cout<<“(“<<stack[m].i<<““<<stack[m].j<<“ “;

                                     if( (m + 1) % 4 == 0)

                                     {

                                               cout<<endl;

                                     }

                            }

                            return ;

                   }

 

                   isFind = false;

                   while(dir < 4 && !isFind )//dir1时向左;dir2时向右;dir3时向上;dir4时向下;

                   {

                            //cout<<n<<endl;

                            dir++;//这个可以实现当这次路径搜索不成功回溯时,可以搜索另一个方向是否有路

                            switch (dir)

                            {

                            case 1: di = stack[top].i – 1;dj = stack[top].j ;break;

                            case 2: di = stack[top].i + 1;dj =stack[top].j;break;

                            case 3: di = stack[top].i;dj = stack[top].j – 1;break;

                            case 4:di = stack[top].i; dj=stack[top].j + 1;break;

                            default:break;

                            }

                            if(map[di][dj] == 0)//当前有路可走

                            {

                                     isFind = true;

                                     //cout<<“di:”<<di<<”  dj”<<dj<<”  n:”<<n<<endl;

                                    

                            }

                   }

                   if(isFind)//如果有路可走

                            {

                                     map[di][dj] = 2;//置当前点已经访问过,否则会造成循环总是在这个点和下个点之间死循环

                                     stack[top].dir = dir;//修改当前搜索的方向为dir

                                     top++;//入栈

                                    

                                     stack[top].i = di;//修改栈顶的i,j下标

                                     stack[top].j = dj;

                            }

                            else//此路不通

                            {

                                     map[stack[top].i][stack[top].j] = 0;//恢复当前点为可走

                                     top–;

                                     //map[di][dj] = 0;

                            }

         }

         cout<<“没有找到路径!“<<endl;

}

 

int _tmain(int argc, _TCHAR* argv[])

{

    int len=sizeof(map)/sizeof(int);//获得整一个map数组的大小

    int len2=sizeof(map[0])/sizeof(int);//获得数组中二维的大小

    int len3=len/len2;//获得数组中一维的大小

        

         cout<<“地图初始化如下:”<<endl;

         for (int i = 0; i < len3; i++)

         {

                   for (int j = 0; j < len2; j++)

                   {

                            cout<<map[i][j]<<” “;

                   }

                   cout<<endl;

         }

         Search(1,1,8,2);//搜索[1][1][9][8]的路径

         return 0;

}

 

上面的注释就是本人的理解,如果哪里有说的不对,还希望多多包涵。

    原文作者:迷宫问题
    原文地址: https://blog.csdn.net/a576480634/article/details/9066819
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞