【数据结构】74_图的广度优先遍历（BFS）

图的选择

MatrixGraph vs ListGraph 如何选择 ？

时间复杂度的对比分析

小结论

• MatrixGraph 适用于内存资源富足的场合（性能较好）
• ListGrap 适用于内存资源受限的场合 （节省空间）

图的遍历

从图中的某一顶点出发，沿着一些边访问图中的其它顶点，使得每个顶点最多被访问一次。

注：从某个顶点出发进行遍历，不一定能够访问到图中的所有顶点。

图的遍历方式

• 广度优先 (Breadth First Search)

  • 以二叉树层次遍历的思想对图进行变脸

• 深度优先 (Depth First Search)

  • 以二叉树先序遍历的思想对图进行遍历

广度遍历 （BFS）

广度优先算法

• 原料： class LinkQueue<T>;

• 步骤：

  1. 将起始顶点压入队列
  2. 队头顶点 v 弹出，判断是否已经标记（标记：转2；未标记：转3）
  3. 标记顶点 v，并将顶点 v 的邻接顶点压入队列中
  4. 判断队列是否为空(非空：转2； 空：结束)

广度优先算法示例

编程实验：广度优先算法

文件：Graph.h

#ifndef GRAPH_H
#define GRAPH_H

#include "Object.h"
#include "SharedPointer.h"
#include "DynamicArray.h"
#include "LinkQueue.h"

namespace DTLib
{

template <typename E>
struct Edge : public Object
{
    int b;
    int e;
    E data;

    Edge(int i=-1, int j=-1)  : b(i), e(j)
    {
    }

    Edge(int i, int j, const E &value) : b(i), e(j), data(value)
    {
    }

    bool operator == (const Edge &obj)
    {
        return (b == obj.b) && (e == obj.e);
    }

    bool operator != (const Edge &obj)
    {
        return !(*this == obj);
    }
};

template <typename V, typename E>
class Graph : public Object
{
public:
    virtual V getVertex(int i) const = 0;
    virtual bool getVertex(int i, V &value) const = 0;
    virtual bool setVertex(int i, const V &value) = 0;
    virtual SharedPointer<Array<int>> getAdjacent(int i) const = 0;
    virtual E getEdge(int i, int j) const = 0;
    virtual bool getEdge(int i, int j, E &value) const = 0;
    virtual bool setEdge(int i, int j, const E &value) = 0;
    virtual bool removeEdge(int i, int j) = 0;
    virtual int vCount() const = 0;
    virtual int eCount() = 0;
    virtual int OD(int i) = 0;
    virtual int ID(int i) = 0;
    virtual int TD(int i)
    {
        return OD(i) + ID(i);
    }

    SharedPointer<Array<int>> BFS(int i)
    {
        DynamicArray<int> *ret = nullptr;

        if ((0 <= i) && (i < vCount()))
        {
            LinkQueue<int> q;
            LinkQueue<int> r;
            DynamicArray<bool> visited(vCount());

            for (int i=0; i<visited.length(); ++i)
            {
                visited[i] = false;
            }

            q.add(i);

            while (q.length() > 0)
            {
                int v = q.front();

                q.remove();

                if (!visited[v])
                {
                    SharedPointer<Array<int>> aj = getAdjacent(v);

                    for (int i=0; i<aj->length(); ++i)
                    {
                        q.add((*aj)[i]);
                    }

                    r.add(v);

                    visited[v] = true;
                }
            }

            ret = toArray(r);
        }
        else
        {
            THROW_EXCEPTION(InvalidParameterExcetion, "Parameter i is invalid ...");
        }

        return ret;
    }

protected:
    template <typename T>
    DynamicArray<T>* toArray(LinkQueue<T> &queue)
    {
        DynamicArray<T> *ret = new DynamicArray<T>(queue.length());

        if (ret != nullptr)
        {
            for (int i=0; i<ret->length(); ++i, queue.remove())
            {
                ret->set(i, queue.front());
            }
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create ret obj ...");
        }

        return ret;
    }
};

}

#endif // GRAPH_H

文件：main.cpp

#include <iostream>
#include "MatrixGraph.h"

using namespace std;
using namespace DTLib;

int main()
{
    MatrixGraph<9, char, int> g;
    const char* VD = "ABEDCGFHI";

    for(int i=0; i<9; i++)
    {
        g.setVertex(0, VD[i]);
    }

    g.setEdge(0, 1, 0);
    g.setEdge(1, 0, 0);

    g.setEdge(0, 3, 0);
    g.setEdge(3, 0, 0);

    g.setEdge(0, 4, 0);
    g.setEdge(4, 0, 0);

    g.setEdge(1, 2, 0);
    g.setEdge(2, 1, 0);

    g.setEdge(1, 4, 0);
    g.setEdge(4, 1, 0);

    g.setEdge(2, 5, 0);
    g.setEdge(5, 2, 0);

    g.setEdge(3, 6, 0);
    g.setEdge(6, 3, 0);

    g.setEdge(4, 6, 0);
    g.setEdge(6, 4, 0);

    g.setEdge(6, 7, 0);
    g.setEdge(7, 6, 0);

    g.setEdge(7, 8, 0);
    g.setEdge(8, 7, 0);

    SharedPointer<Array<int>> sa = g.BFS(0);

    for (int i=0; i<sa->length(); ++i)
    {
        cout << (*sa)[i] << " ";
    }

    cout << endl;

    return 0;
};

输出：

0 1 3 4 2 6 5 7 8

小结

• MatrixGraph 适用于资源富足的场合
• ListGraph 适用于资源受限的场合
• 广度优先按照 "层次的方式" 对顶点进行访问
• 广度优先算法的核心的是队列的使用

以上内容整理于狄泰软件学院系列课程，请大家保护原创！