数据结构（c++版） 第六章

数据结构（c++版）第六章 图

本章的主要内容是:

1、 图的逻辑结构

2、图的存储结构及实现

3、最小生成树

4、最短路径

5、AOV网与拓扑排序

6、AOE网与关键路径

6.1 图的逻辑结构

（一）图的定义

1、图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：

                           G=(V，E)

其中：G表示一个图，V是图G中顶点的集合，E是图G中顶点之间边的集合。

注意：

（1）在线性表中，元素个数可以为零，称为空表；

（2）在树中，结点个数可以为零，称为空树；

（3）在图中，顶点个数不能为零，但可以没有边。

2、无向边：

若顶点vi和vj之间的边没有方向，则称这条边为无向边，表示为(vi,vj)。

3、 无向图：

如果图的任意两个顶点之间的边都是无向边，则称该图为无向图。

4、 有向边：

若从顶点vi到vj的边有方向，则称这条边为有向边，表示为<vi,vj>。

5、 有向图：

如果图的任意两个顶点之间的边都是有向边，则称该图为有向图。

图的基本术语

（二）图的基本术语

1、简单图：在图中，若不存在顶点到其自身的边，且同一条边不重复出现。

注意：数据结构中讨论的都是简单图。

2、邻接、依附

（1）无向图中，对于任意两个顶点vi和顶点vj，若存在边(vi，vj)，则称顶点vi和顶点vj互为邻接点，同时称边(vi，vj)依附于顶点vi和顶点vj。

（2）有向图中，对于任意两个顶点vi和顶点vj，若存在弧<vi，vj>，则称顶点vi邻接到顶点vj，顶点vj邻接自顶点vi，同时称弧<vi，vj>依附于顶点vi和顶点vj。

3、无向完全图：在无向图中，如果任意两个顶点之间都存在边，则称该图为无向完全图。

4、有向完全图：在有向图中，如果任意两个顶点之间都存在方向相反的两条弧，则称该图为有向完全图。 

5、含有n个顶点的无向完全图有n×(n-1)/2条边。

含有n个顶点的有向完全图有n×(n-1)条边。

6、1稀疏图：称边数很少的图为稀疏图；

2稠密图：称边数很多的图为稠密图。

7、顶点的度：在无向图中，顶点v的度是指依附于该顶点的边数，通常记为TD (v)。

8、1顶点的入度：在有向图中，顶点v的入度是指以该顶点为弧头的弧的数目，记为ID (v)；

2顶点的出度：在有向图中，顶点v的出度是指以该顶点为弧尾的弧的数目，记为OD (v)。

9、权：是指对边赋予的有意义的数值量。

网：边上带权的图，也称网图。

10、路径：在无向图G=(V, E)中，从顶点vp到顶点vq之间的路径是一个顶点序列(vp=vi0,vi1,vi2,…,vim=vq)，其中，(vij-1,vij)∈E（1≤j≤m）。若G是有向图，则路径也是有方向的，顶点序列满足<vij-1,vij>∈E。

   （一般情况下，图中的路径不惟一）

11、回路（环）：第一个顶点和最后一个顶点相同的路径。

12、简单路径：序列中顶点不重复出现的路径。

13、简单回路（简单环）：除了第一个顶点和最后一个顶点外，其余顶点不重复出现的回路。

14、子图：若图G=（V，E），G'=（V'，E'），如果V'ÍV 且E' ÍE ，则称图G'是G的子图。

15、连通图：在无向图中，如果从一个顶点vi到另一个顶点vj(i≠j)有路径，则称顶点vi和vj是连通的。如果图中任意两个顶点都是连通的，则称该图是连通图。

16、连通分量：非连通图的极大连通子图称为连通分量。

17、强连通图：在有向图中，对图中任意一对顶点vi和vj (i≠j)，若从顶点vi到顶点vj和从顶点vj到顶点vi均有路径，则称该有向图是强连通图。

18、强连通分量：非强连通图的极大强连通子图。

19、生成树：n个顶点的连通图G的生成树是包含G中全部顶点的一个极小连通子图。

20、生成森林：在非连通图中，由每个连通分量都可以得到一棵生成树，这些连通分量的生成树就组成了一个非连通图的生成森林。

（三）不同结构中逻辑关系的对比

1、在线性结构中，数据元素之间仅具有线性关系；

2、在树结构中，结点之间具有层次关系；

3、在图结构中，任意两个顶点之间都可能有关系。

4、在线性结构中，元素之间的关系为前驱和后继；

5、在树结构中，结点之间的关系为双亲和孩子；

6、在图结构中，顶点之间的关系为邻接。

（四）图的抽象数据类型定义

1、ADT  Graph

Data

   顶点的有穷非空集合和边的集合

Operation

InitGraph

    前置条件：图不存在

    输入：无

    功能：图的初始化

    输出：无

    后置条件：构造一个空的图

DestroyGraph

    前置条件：图已存在

    输入：无

    功能：销毁图

    输出：无

    后置条件：释放图所占用的存储空间

DFSTraverse

    前置条件：图已存在

    输入：遍历的起始顶点v

    功能：从顶点v出发深度优先遍历图

    输出：图中顶点的一个线性排列

    后置条件：图保持不变

 BFSTraverse

    前置条件：图已存在

    输入：遍历的起始顶点v

    功能：从顶点v出发广度优先遍历图

    输出：图中顶点的一个线性排列

    后置条件：图保持不变

endADT

2、图的遍历操作

图的遍历是在从图中某一顶点出发，对图中所有顶点访问一次且仅访问一次。

（抽象操作，可以是对结点进行的各种处理，这里简化为输出结点的数据。）

（1）图的遍历操作要解决的关键问题

① 在图中，如何选取遍历的起始顶点？

解决方案：从编号小的顶点开始 。

n  在线性表中，数据元素在表中的编号就是元素在序列中的位置，因而其编号是唯一的；

n  在树中，将结点按层序编号，由于树具有层次性，因而其层序编号也是唯一的；

n  在图中，任何两个顶点之间都可能存在边，顶点是没有确定的先后次序的，所以，顶点的编号不唯一。

为了定义操作的方便，将图中的顶点按任意顺序排列起来，比如，按顶点的存储顺序。

② 从某个起点始可能到达不了所有其它顶点，怎么办？

解决方案：多次调用从某顶点出发遍历图的算法。

③ 因图中可能存在回路，某些顶点可能会被重复访问，那么如何避免遍历不会因回路而陷入死循环。

解决方案：附设访问标志数组visited[n]。

④ 在图中，一个顶点可以和其它多个顶点相连，当这样的顶点访问过后，如何选取下一个要访问的顶点？

解决方案：深度优先遍历和广度优先遍历。

（2）深度优先遍历

l  基本思想 ：

1 访问顶点v；

2从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；

3 重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。

l  从顶点v出发图的深度优先遍历算法的伪代码：

1 访问顶点v; visited[v] = 1;

2w =顶点v的第一个邻接点；

3 while (w存在)

   3.1 if (w未被访问) 从顶点w出发递归执行该算法;

3.2 w = 顶点v的下一个邻接点;

（2）广度优先遍历

l  基本思想：

1访问顶点v；

2依次访问v的各个未被访问的邻接点v1, v2, …, vk；

3 分别从v1，v2，…，vk出发依次访问它们未被访问的邻接点，并使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问。直至图中所有与顶点v有路径相通的顶点都被访问到。

l  从顶点v出发图的广度优先遍历算法的伪代码：

1 初始化队列Q;

2访问顶点v; visited [v]=1; 顶点v入队列Q;

3while (队列Q非空)

   3.1 v=队列Q的队头元素出队;

   3.2 w=顶点v的第一个邻接点;

   3.3 while (w存在)

         3.3.1 如果w 未被访问，则

                   访问顶点w; visited[w]=1; 顶点w入队列Q；

         3.3.2 w=顶点v的下一个邻接点；

6.2 图的存储结构及实现

1、图的特点：顶点之间的关系是m:n，即任何两个顶点之间都可能存在关系（边），无法通过存储位置表示这种任意的逻辑关系，所以，图无法采用顺序存储结构。

（一）邻接矩阵（数组表示法）

1、基本思想：用一个一维数组存储图中顶点的信息，用一个二维数组（称为邻接矩阵）存储图中各顶点之间的邻接关系。

2、无向图的邻接矩阵

（1）无向图的邻接矩阵的特点：

主对角线为 0 且一定是对称矩阵。

（2）如何求顶点i的度？

邻接矩阵的第i行（或第i列）非零元素的个数。

（3）如何判断顶点 i 和 j 之间是否存在边？

测试邻接矩阵中相应位置的元素arc[i][j]是否为1。

（4）如何求顶点 i 的所有邻接点？

将数组中第 i 行元素扫描一遍，若arc[i][j]为1，则顶点 j 为顶点i 的邻接点。

3、有向图的邻接矩阵

（1）有向图的邻接矩阵一定不对称吗？

不一定，例如有向完全图。

（2）如何求顶点 i 的出度？

邻接矩阵的第 i 行元素之和。

（3）如何求顶点 i 的入度？

邻接矩阵的第 i 列元素之和。

（4）如何判断从顶点 i 到顶点 j 是否存在边？

测试邻接矩阵中相应位置的元素arc[i][j]是否为1。

4、网图的邻接矩阵

（1）邻接矩阵存储无向图的类

const int MaxSize=10;

template <class DataType>

class Mgraph

{

  public:

     MGraph(DataType a[ ], int n, int e );  

      ~MGraph( )

      void DFSTraverse(int v);

      void BFSTraverse(int v);

   private:

      DataType vertex[MaxSize];

      int arc[MaxSize][MaxSize];

      int vertexNum, arcNum;

};

（2）邻接矩阵中图的基本操作——构造函数

1确定图的顶点个数和边的个数；

2 输入顶点信息存储在一维数组vertex中；

3初始化邻接矩阵；

4依次输入每条边存储在邻接矩阵arc中；

    4.1 输入边依附的两个顶点的序号i, j；

    4.2 将邻接矩阵的第i行第j列的元素值置为1；

    4.3 将邻接矩阵的第j行第i列的元素值置为1；

template <class DataType>

MGraph<DataType> ::MGraph(DataType a[ ], int n, int e)

{

   vertexNum = n; arcNum = e;

   for (i = 0; i < vertexNum; i++)

       vertex[i] = a[i];

   for (i = 0; i < vertexNum; i++)          //初始化邻接矩阵

       for (j = 0; j < vertexNum; j++)

            arc[i][j] = 0;            

   for (k = 0; k < arcNum; k++)          //依次输入每一条边

   {

       cin >> i >> j;                     //输入边依附的两个顶点的编号

       arc[i][j] = 1; arc[j][i] = 1;            //置有边标志

   }

}

（3）邻接矩阵中图的基本操作——深度优先遍历

template <class DataType>

void MGraph<DataType> ::DFSTraverse(int v) 

{

   cout << vertex[v]; visited[v] = 1;

   for (j = 0; j < vertexNum; j++)

       if (arc[v][j] == 1 && visited[j] == 0) DFSTraverse( j );

}

（4）邻接矩阵中图的基本操作——广度优先遍历

template <class DataType>

void MGraph<DataType> ::BFSTraverse(int v)

{

   front = rear = -1;   //初始化顺序队列

   cout << vertex[v]; visited[v] = 1; Q[++rear] = v;

   while (front != rear)                  //当队列非空时

   {

        v = Q[++front];                  //将队头元素出队并送到v中

       for (j = 0; j < vertexNum; j++)

            if (arc[v][j] == 1 &&visited[j] == 0 ) {

                 cout << vertex[j]; visited[j]= 1; Q[++rear] = j;

            }

   }

}

5、邻接表

（1）邻接表存储的基本思想：对于图的每个顶点v_i，将所有邻接于v_i的顶点链成一个单链表，称为顶点v_i的边表（对于有向图则称为出边表），所有边表的头指针和存储顶点信息的一维数组构成了顶点表。

（2）定义邻接表的结点

struct ArcNode

{  

   int adjvex;

   ArcNode *next;

};

template <class DataType>

struct VertexNode

{

   DataType vertex;

   ArcNode *firstedge;

};

（3）邻接表存储有向图的类

const int MaxSize = 10;    //图的最大顶点数

template <class DataType>

class ALGraph

{   

  public:

      ALGraph(DataType a[ ], int n, int e);  

      ~ALGraph;   

      void DFSTraverse(int v);     

      void BFSTraverse(int v);     

 private:

      VertexNode adjlist[MaxSize];  

      int vertexNum, arcNum;      

};

（4）邻接表中图的基本操作——构造函数

1. 确定图的顶点个数和边的个数；

2. 输入顶点信息，初始化该顶点的边表；

3. 依次输入边的信息并存储在边表中；

    3.1  输入边所依附的两个顶点的序号i和j；

    3.2  生成邻接点序号为j的边表结点s；

   3.3 将结点s插入到第i个边表的头部；

template <class DataType>

ALGraph<DataType> ::ALGraph(DataType a[ ], int n, int e)

{

   vertexNum = n; arcNum = e;

   for (i = 0; i < vertexNum; i++)

  {                                            //输入顶点信息，初始化顶点表

       adjlist[i].vertex = a[i];

       adjlist[i].firstedge = NULL;     

   }

    for (k = 0; k < arcNum; k++) //输入边的信息存储在边表中

   {

        cin>>i>>j;   

        s = new ArcNode; s->adjvex = j;           

        s->next = adjlist[i].firstedge;   

        adjlist[i].firstedge = s;

    }

}

（5）邻接表中图的基本操作——深度优先遍历

template <class DataType>

void ALGraph<DataType> ::DFSTraverse(int v)

{

   cout << adjlist[v].vertex; visited[v] = 1;

   p = adjlist[v].firstedge;       //工作指针p指向顶点v的边表

   while (p != NULL)              //依次搜索顶点v的邻接点j

   {

       j = p->adjvex;

       if (visited[j] == 0) DFSTraverse(j);

       p = p->next;          

   }

}

（6）邻接表中图的基本操作——广度优先遍历

template <class DataType>

void ALGraph<DataType> :: BFSTraverse(intv)

{

   front = rear = -1;   //初始化顺序队列

   cout << adjlist[v].vertex; visited[v] = 1; Q[++rear] = v;

   while (front != rear)           //当队列非空时

   {

       v = Q[++front];

       p = adjlist[v].firstarc;       //工作指针p指向顶点v的边表

       while (p != NULL)

       {

            j = p->adjvex;

            if (visited[j] == 0) {

               cout << adjlist[j].vertex;visited[j] = 1;Q[++rear] = j;

           }

           p=p->next;

       }

   }

}

6.3 最小生成树

（一）最小生成树的定义

1、生成树的代价：设G = (V, E)是一个无向连通网，生成树上各边的权值之和称为该生成树的代价。

2、最小生成树：在图G所有生成树中，代价最小的生成树称为最小生成树。 

（二）普里姆（Prim）算法

1、基本思想：设G=(V, E)是具有n个顶点的连通网，T=(U,TE)是G的最小生成树， T的初始状态为U={u₀}（u₀∈V），TE={ }，重复执行下述操作：在所有u∈U，v∈V-U的边中找一条代价最小的边(u,v)并入集合TE，同时v并入U，直至U=V。

2、Prim算法的基本思想用伪代码描述如下：

（1）初始化：U = {v0}； TE={ }；

（2）重复下述操作直到U = V：

   2.1 在E中寻找最短边(u，v)，且满足u∈U，v∈V-U；

   2.2 U = U + {v}；

   2.3 TE = TE + {(u，v)}；

3、Prim算法——伪代码

（1） 初始化两个辅助数组lowcost和adjvex；

（2）输出顶点u₀，将顶点u₀加入集合U中；

（3）重复执行下列操作n-1次

  3.1 在lowcost中选取最短边，取adjvex中对应的顶点序号k；

  3.2 输出顶点k和对应的权值；

  3.3 将顶点k加入集合U中；

  3.4 调整数组lowcost和adjvex；

（三）克鲁斯卡尔（Kruskal）算法

1、基本思想：设无向连通网为G＝(V, E)，令G的最小生成树为T＝(U,TE)，其初态为U＝V，TE＝{ }，然后，按照边的权值由小到大的顺序，考察G的边集E中的各条边。若被考察的边的两个顶点属于T的两个不同的连通分量，则将此边作为最小生成树的边加入到T中，同时把两个连通分量连接为一个连通分量；若被考察边的两个顶点属于同一个连通分量，则舍去此边，以免造成回路，如此下去，当T中的连通分量个数为1时，此连通分量便为G的一棵最小生成树。

2、Kruskal算法的基本思想用伪代码描述如下：

（1）初始化：U=V；TE={ }；

（2）重复下述操作直到T中的连通分量个数为1：

   2.1 在E中寻找最短边(u，v);

   2.2 如果顶点u、v位于T的两个不同连通分量，则

         2.2.1 将边(u，v)并入TE；

         2.2.2 将这两个连通分量合为一个；

   2.3 标记边(u，v)，使得(u，v)不参加后续最短边的选取；

 3、Kruskal算法用伪代码进一步描述为

（1）初始化辅助数组parent[n]；num = 0；

（2）依次考查每一条边for (i = 0; i < arcNum;i++)

   2.1 vex1 = edge[i].from所在生成树的根结点；

   2.2 vex2 = edge[i].to所在生成树的根结点；

   2.3 如果vex1 != vex2，执行下述操作：

         2.3.1 parent[vex2] = vex1;

         2.3.2 num++;

         2.3.3 if (num == n-1) 算法结束；

6.4 最短路径

1、在非网图中，最短路径是指两顶点之间经历的边数最少的路径。

2、在网图中，最短路径是指两顶点之间经历的边上权值之和最短的路径。

（一）Dijkstra算法

1、基本思想：设置一个集合S存放已经找到最短路径的顶点，S的初始状态只包含源点v，对v_i∈V-S，假设从源点v到v_i的有向边为最短路径。以后每求得一条最短路径v, …,v_k，就将v_k加入集合S中，并将路径v, …,v_k , v_i与原来的假设相比较，取路径长度较小者为最短路径。重复上述过程，直到集合V中全部顶点加入到集合S中。

2、Dijkstra算法——伪代码

1）初始化数组dist、path和s；

2）while (s中的元素个数<n)

    2.1 在dist[n]中求最小值，其下标为k；

    2.2 输出dist[j]和path[j]；

    2.3 修改数组dist和path；

    2.4 将顶点v_k添加到数组s中；

（二）数据结构 :

1、图的存储结构：带权的邻接矩阵存储结构 

2、数组dist[n]：每个分量dist[i]表示当前所找到的从始点v到终点v_i的最短路径的长度。初态为：若从v到v_i有弧，则dist[i]为弧上权值；否则置dist[i]为∞。

3、数组path[n]：path[i]是一个字符串，表示当前所找到的从始点v到终点v_i的最短路径。初态为：若从v到v_i有弧，则path[i]为vv_i；否则置path[i]空串。

4、数组s[n]：存放源点和已经生成的终点，其初态为只有一个源点v。

（三）Floyd算法

1、基本思想：对于从v_i到v_j的弧，进行n次试探：首先考虑路径v_i,v₀,v_j是否存在，如果存在，则比较v_i,v_j和v_i,v₀,v_j的路径长度，取较短者为从v_i到v_j的中间顶点的序号不大于0的最短路径。在路径上再增加一个顶点v₁，依此类推，在经过n次比较后，最后求得的必是从顶点v_i到顶点v_j的最短路径。 

2、Floyd算法——C++描述

void Floyd(MGraph G)

{

   for (i=0; i<G.vertexNum; i++)       

       for (j=0; j<G.vertexNum; j++)

       {

         dist[i][j]=G.arc[i][j];

          if (dist[i][j]!=∞)

              path[i][j]=G.vertex[i]+G.vertex[j];

          else path[i][j]="";

      }

   for (k=0; k<G.vertexNum; k++)        

        for(i=0; i<G.vertexNum; i++)      

           for (j=0; j<G.vertexNum; j++)

               if (dist[i][k]+dist[k][j]<dist[i][j]){

                    dist[i][j]=dist[i][k]+dist[k][j];

                    path[i][j]=path[i][k]+path[k][j];

              }

}