数据结构与算法：广度寻路算法的C++实现

任务：初始化一个10*10的地图（利用整型变量模拟，1代表墙壁，0代表通路），给定起始位置和目标位置，利用广度寻路算法找到最短路径。

main.cpp代码如下：

#include <iostream>
#include <vector>

#define ROWS 10
#define COLS 10

using namespace std;

//枚举类型，表示探索方向
enum Direct { D_up, D_right, D_down, D_left};

//定义辅助地图标记点
struct Mark {
    int  val;        //整型变量  0表示通路，1表示墙壁
    bool bIsFind;    //该点位是否已被探索
};

//定义位置坐标
struct Pos
{
    int Row;     //所处行数
    int Col;     //所处列数
};

//定义寻路树结构
struct NodeTree {
    Pos                  MyPos = {0,0};         //自身位置坐标
    NodeTree*            pParent = NULL;        //父结点地址
    vector<NodeTree*>    pChild;                //孩子结点地址容器
};  

//创建新结点
NodeTree* CreateNewNode(int Row, int Col);


int main()
{
    //初始化原地图
    int Map[ROWS][COLS] =
    {
        {1,1,1,1,1,1,1,1,1,1},
        {1,0,1,1,1,1,1,1,1,1},
        {1,0,1,1,1,1,0,0,0,1},
        {1,0,0,0,1,1,0,1,0,1},
        {1,0,1,0,0,0,0,1,0,1},
        {1,0,0,0,1,1,0,1,0,1},
        {1,0,1,0,0,0,0,1,0,1},
        {1,0,1,0,1,1,0,1,0,1},
        {1,0,0,0,1,1,0,0,0,1},
        {1,1,1,1,1,1,1,1,1,1},
    };

    //初始化辅助地图
    Mark PathMap[ROWS][COLS] = { 0 };
    for (int i = 0; i < ROWS; i++)
    {
        for (int j = 0; j < COLS; j++)
        {
            PathMap[i][j].val = Map[i][j];
        }
    }

    //初始化起始位置和目标位置
    Pos SrcPos = { 1 , 1 };
    Pos DstPos = { 8 , 8 };

    //初始化寻路树，将起始位置设为根结点
    NodeTree* pRoot = NULL;
    pRoot = CreateNewNode(SrcPos.Row, SrcPos.Col);

    //当前结点位置
    Pos TempPos = SrcPos;
    PathMap[TempPos.Row][TempPos.Col].bIsFind = true;

    //初始化当前层
    vector<NodeTree*> pBuff;
    pBuff.push_back(pRoot);

    //临时结点
    NodeTree* TempNode = NULL;

    bool bFindPath = false;

    while (!bFindPath)
    {
        //初始化下一层
        vector<NodeTree*> pNextBuff;
        //探索每个孩子
        for (unsigned int i = 0; i < pBuff.size(); i++)
        {
            //探索每个方向
            for (int j = 0; j < 4; j++)
            {
                TempPos = pBuff[i]->MyPos;
                switch (j)
                { 
                case  D_up:     TempPos.Row--;  break;
                case  D_right:  TempPos.Col++;  break;
                case  D_down:   TempPos.Row++;   break;
                case  D_left:   TempPos.Col--;   break;
                }
                //如果通路未被探索
                if (PathMap[TempPos.Row][TempPos.Col].val == 0 && !PathMap[TempPos.Row][TempPos.Col].bIsFind)
                {
                    //则新增树结点加入树中
                    TempNode = CreateNewNode(TempPos.Row, TempPos.Col);
                    TempNode->pParent = pBuff[i];
                    pBuff[i]->pChild.push_back(TempNode);
                    //该位置标记为已探索
                    PathMap[TempPos.Row][TempPos.Col].bIsFind = true;
                    //将结点添加至下一层容器
                    pNextBuff.push_back(TempNode);
                    //cout << "(" << TempNode->MyPos.Row << "," << TempNode->MyPos.Col << ")" << endl;                
                }
                //如果当前坐标等于目标位置坐标，寻路成功，退出循环
                if (TempPos.Row == DstPos.Row && TempPos.Col == DstPos.Col)
                {
                    bFindPath = true;
                  //cout << "findpath"<<endl;
                    break;
                }
            }
            //寻路成功，退出循环
            if(bFindPath) break;
        }
        //寻路成功，退出循环
        if (bFindPath) break;
        //当前层移至下一层
        pBuff = pNextBuff;
    }
    //寻路成功则打印路径信息
    if (bFindPath && TempNode)
    {
        cout << "寻路成功，路径如下：" << endl;
        while (TempNode->pParent)
        {
            cout << "(" << TempNode->MyPos.Row << "," << TempNode->MyPos.Col << ")" << endl;
            TempNode = TempNode->pParent;
        }
        cout << "(" << TempNode->MyPos.Row << "," << TempNode->MyPos.Col << ")" << endl;
    }
    else
    {
        cout << "ERROR!" << endl;
    }

    return 0;
}


//创建新结点
NodeTree* CreateNewNode(int Row, int Col)
{
    NodeTree* pNew = new NodeTree;
    memset(pNew, 0, sizeof(NodeTree));
    pNew->MyPos.Col = Col;
    pNew->MyPos.Row = Row;
    return pNew;
}

程序运行结果如下：