图的广度优先遍历&深度优先遍历

图的广度优先遍历

广度优先搜索（Breadth_First Search） 遍历类似于树的按层次遍历的过程。

假设从图中某顶点v 出发，在访问了v 之后依次访问v 的各个未曾访问过和邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问，直至图中所有已被访问的顶点的邻接点都被访问到。若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。换句话说，广度优先搜索遍历图的过程中以v 为起始点，由近至远，依次访问和v 有路径相通且路径长度为1,2,…的顶点。

//图的广度优先遍历
    void BFS(const V& value)
    {
        cout << "广度优先遍历序列：";
        queue q;
        int size = _v.size();
        vector<bool> visted;//标记顶点是否被遍历
        int index = GetIndexOfV(value);

        visted.resize(size, false);//初始化为都未访问过
        q.push(index);
        _BFS(q, visted);

        //遍历与当前子图不连通的子图
        for (size_t i = 0; i < size; ++i)
        {
            if(visted[i] == false)
            {
                q.push(i);
                _BFS(q, visted);
            }
        }
        cout << endl;
    }

void _BFS(queue& q, vector<bool>& visted)
    {
        while (!q.empty())
        {
            int index = q.front();
            if (visted[index] == false)//未被遍历
            {
                cout << _v[index] << " ";//遍历
                visted[index] = true;//更新visted为true

                PNode pCur = _linkEdges[index];//指向当前结点
                while (pCur)
                {
                    q.push(pCur->_dst);
                    pCur = pCur->_pNext;
                }
            }
            q.pop();
        }
    }

图的深度优先遍历

深度优先搜索（Depth_Fisrst Search）遍历类似于树的先根遍历，是树的先根遍历的推广。

假设初始状态是图中所有顶点未曾被访问，则深度优先搜索可从图中某个顶点发v 出发，访问此顶点，然后依次从v 的未被访问的邻接点出发深度优先遍历图，直至图中所有和v 有路径相通的顶点都被访问到；若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。

//图的深度优先遍历
    void DFS(const V& value)
    {
        cout << "深度优先遍历序列：";
        int size = _v.size();
        size_t index = GetIndexOfV(value);
        vector<bool> visted;
        visted.resize(size, false);
        _DFS(index, visted);

        for (size_t i = 0; i < size; ++i)
        {
            if (visted[i] == false)
                _DFS(i, visted);
        }
        cout << endl;
    }

    void _DFS(size_t index,vector<bool>& visted)
    {
        cout << _v[index] << " ";
        visted[index] = true;

        PNode pCur = _linkEdges[index];
        while (pCur)
        {
            if (visted[pCur->_dst] == false)
                _DFS(pCur->_dst, visted);
            pCur = pCur->_pNext;
        }
    }

测试函数：

void test2()
{
    char array[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K' };
    Graph g(array, sizeof(array) / sizeof(array[0]));

    g.AddEdge('A', 'B', 10);
    g.AddEdge('A', 'C', 20);
    g.AddEdge('A', 'D', 30);
    g.AddEdge('B', 'E', 40);
    g.AddEdge('B', 'C', 50);
    g.AddEdge('C', 'F', 60);
    g.AddEdge('D', 'F', 70);
    g.AddEdge('F', 'H', 80);
    g.AddEdge('H', 'I', 90);
    g.AddEdge('E', 'G', 100);
    g.AddEdge('J', 'K', 10);

    g.BFS('A');
    g.DFS('A');
}

构建的图为：

广度优先遍历：

深度优先遍历：

程序结果：