C#数据结构与算法揭秘13

这节，我们来看看一下什么了，来看看图的遍历吧！

首先，搞清楚，图的遍历的基本的含义了。

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

然而，图的遍历要比树的遍历复杂得多。这是因为图中的顶点之间是多对多的关系，图中的任何一个顶点都可能和其它的顶点相邻接。所以，在访问了某个顶点之后， 从该顶点出发， 可能沿着某条路径遍历之后， 又回到该顶点上。 例如，在下图中，由于图中存在回路，因此在访问了 A、B、C、D、E之后，沿着边<E,A>为图中顶点的数目。数组中元素的初始值全为 0，表示顶点都没有被访问过，如果顶点vi 被访问，visited[i-1]为 1。

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

首先，介绍了一些优先遍历。

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

我们先回顾一下树的先序遍历，如图所示：

他先序遍历结果是ABDEFCFG。

那图的图的深度优先遍历，究竟是那样的。

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

下图(a)所示的无向图的深度优先遍历的过程如下图(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;
}

//以下为添加的代码

//所有的结点，都没有访问过。 都赋值为0
visited = new int[adjList.Length];
for (int i = 0; i < visited.Length; ++i)
{
visited[i] = 0;
}
}

由于，他是循环遍历，他的时间的复杂度是O(n).

无向图的深度优先遍历算法的实现如下：   
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)。具体情况，如图所示：

下面介绍广度遍历。

图的广度优先遍历（Breadth_First Search）类似于树的层序遍历。 我们回顾一下树的层次遍历，如图所示：

树的层次遍历结果为ABCDEFG。

那图的光序遍历为

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

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

和深度优先遍历类似，在广度优先遍历中也需要一个访问标记数组，我们采用与深度优先遍历同样的数组。并且，为了顺序访问路径长度为 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);

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;
}
}
}

算法的复杂度是O(n2),具体情况，如图所示：

 

cq.In(i);

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

这就是图的遍历，极其算法的实现，下届，我们讨论图的应用。