C#-数据结构-图的遍历

图的遍历是指从图中的某个顶点出发，按照某种顺序访问图中的每个顶点， 使每个顶点被访问一次且仅一次。图的遍历与树的遍历操作功能相似。图的遍历 是图的一种基本操作，图的许多其他操作都是建立在遍历操作的基础之上的。

然而，图的遍历要比树的遍历复杂得多。这是因为图中的顶点之间是多对多 的关系，图中的任何一个顶点都可能和其它的顶点相邻接。所以，在访问了某个 顶点之后，从该顶点出发，可能沿着某条路径遍历之后，又回到该顶点上。例如， 在图 6.1(b)的图中，由于图中存在回路，因此在访问了 v1、v3、v4 之后，沿着 边<v4，v1>又回到了 v1 上。为了避免同一顶点被访问多次，在遍历图的过程中， 必须记下每个已访问过的顶点。为此，可以设一个辅助数组 visited[n]，n 为图中 顶点的数目。数组中元素的初始值全为 0，表示顶点都没有被访问过，如果顶点 vi 被访问，visited[i-1]为 1。

图的遍历有深度优先遍历和广度优先遍历两种方式，它们对图和网都适用

6.3.1 深度优先遍历 

图的深度优先遍历（Depth_First Search）类似于树的先序遍历，是树的先序 遍历的推广。

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

 

【例 6-1】按深度优先遍历算法对图 6.13(a)进行遍历。 图 6.13(a)所示的无向图的深度优先遍历的过程如图 6.13(b)所示。假设从顶 点 v1 出发，在访问了顶点 v1 之后，选择邻接顶点 v2，因为 v2 未被访问过，所 以从 v2 出发进行深度优先遍历。依次类推，接着从 v4、v8、v5 出发进行深度优 先遍历。当访问了 v5 之后，由于 v5 的邻接顶点 v2 和 v8 都已被访问，所以遍历 退回到 v8。由于同样的理由，遍历继续退回到 v4、v2 直到 v1。由于 v1 的另一 个邻接顶点 v3 未被访问，所以又从 v3 开始进行深度优先遍历，这样得到该图的 深度优先遍历的顶点序列为 v1→v2→v4→v8→v5→v3→v6→v7。 

显然，这是一个递归的过程。下面以无向图的邻接表存储结构为例来实现图 的深度优先遍历算法。在类中增设了一个整型数组的成员字段 visited，它的初始 值全为 0，表示图中所有的顶点都没有被访问过。如果顶点 vi 被访问，visited[i-1] 为 1。并且，把该算法作为无向图的邻接表类 GraphAdjList<T>的成员方法。

由于增设了成员字段 visited，所以在类的构造器中添加以下代码。 

public GraphAdjList(Node<T>[] nodes)
{
    adjList = new VexNode<T>[nodes.Length]; for (int i = 0; i < nodes.Length; ++i)
    {
        adjList[i].Data = nodes[i]; adjList[i].FirstAdj = null;
    }

    //以下为添加的代码 
    visited = new int[adjList.Length]; for (int i = 0; i < visited.Length; ++i)
    {
        visited[i] = 0;
    }
}

无向图的深度优先遍历算法的实现如下： 

public void DFS()
{
    for (int i = 0; i < visited.Length; ++i)
    {
        if (visited[i] == 0)
        {
            DFSAL(i);
        }
    }
}

//从某个顶点出发进行深度优先遍历 
public void DFSAL(int i)
{
    visited[i] = 1; adjListNode<T> p = adjList[i].FirstAdj;

    while (p != null)
    {
        if (visited[p.Adjvex] == 0)
        {
            DFSAL(p.Adjvex);
        }

        p = p.Next;
    }
}

分析上面的算法，在遍历图时，对图中每个顶点至多调用一次DFS方法，因 为一旦某个顶点被标记成已被访问，就不再从它出发进行遍历。因此，遍历图的过程实质上是对每个顶点查找其邻接顶点的过程。其时间复杂度取决于所采用的 存储结构。当图采用邻接矩阵作为存储结构时，查找每个顶点的邻接顶点的时间 复杂度为O(n2)，其中，n为图的顶点数。而以邻接表作为图的存储结构时，查找 邻接顶点的时间复杂度为O(e)，其中，e为图中边或弧的数目。因此，当以邻接 表作为存储结构时，深度优先遍历图的时间复杂度为O(n+e)。 

6.3.2 广度优先遍历 

图的广度优先遍历（Breadth_First Search）类似于树的层序遍历。 

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

【例 6-2】按广度优先遍历算法对图 6.13(a)进行遍历。 

图 6.13(a)所示的无向图的广度优先遍历的过程如图 6.13(c)所示。假设从顶 点 v1 开始进行广度优先遍历，首先访问顶点 v1 和它的邻接顶点 v2 和 v3，然后 依次访问 v2 的邻接顶点 v4 和 v5，以及 v3 的邻接顶点 v6 和 v7，后访问 v4 的邻接顶点 v8。由于这些顶点的邻接顶点都已被访问，并且图中所有顶点都已 被访问，由此完成了图的遍历，得到的顶点访问序列为：v1→v2→v3→v4→v5 →v6→v7→v8，其遍历过程如图 6.13(c)所示。 

和深度优先遍历类似，在广度优先遍历中也需要一个访问标记数组，我们采 用与深度优先遍历同样的数组。并且，为了顺序访问路径长度为 1，2，…的顶 点，需在算法中附设一个队列来存储已被访问的路径长度为 1，2，…的顶点。 

以邻接表作为存储结构的无向图的广度优先遍历算法的实现如下，队列是循 环顺序队列。 

public void BFS()
{
    for (int i = 0; i < visited.Length; ++i)
    {
        if (visited[i] == 0)
        {
            BFSAL(i);
        }
    }
}

//从某个顶点出发进行广度优先遍历         
public void BFSAL(int i)
{
    visited[i] = 1;
    CSeqQueue<int> cq = new CSeqQueue<int>(visited.Length); cq.In(i);

    while (!cq.IsEmpty())
    {
        int k = cq.Out(); adjListNode<T> p = adjList[k].FirstAdj;

        while (p != null)
        {
            if (visited[p.Adjvex] == 0)
            {
                visited[p.Adjvex] = 1; cq.In(p.Adjvex);
            }

            p = p.Next;
        }
    }
}

 

分析上面的算法，每个顶点至多入队列一次。遍历图的过程实质上是通过边 或弧查找邻接顶点的过程，因此，广度优先遍历算法的时间复杂度与深度优先遍 历相同，两者的不同之处在于对顶点的访问顺序不同