第六章 图

一、图的逻辑结构
（一）
图的定义：图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为G=(V，E)。其中：G表示一个图，V是图G中顶点的集合，E是图G中顶点之间边的集合。
（在线性表中，元素个数可以为零，称为空表；在树中，结点个数可以为零，称为空树；在图中，顶点个数不能为零，但可以没有边。)
简单图：在图中，若不存在顶点到其自身的边，且同一条边不重复出现。
无向完全图：在无向图中，如果任意两个顶点之间都存在边，则称该图为无向完全图。
有向完全图：在有向图中，如果任意两个顶点之间都存在方向相反的两条弧，则称该图为有向完全图。
含有n个顶点的无向完全图有n×(n-1)/2条边。 含有n个顶点的有向完全图有n×(n-1)条边。
稀疏图：称边数很少的图为稀疏图；稠密图：称边数很多的图为稠密图。
顶点的度：在无向图中，顶点v的度是指依附于该顶点的边数，通常记为TD (v)。
顶点的入度：在有向图中，顶点v的入度是指以该顶点为弧头的弧的数目，记为ID (v)；
顶点的出度：在有向图中，顶点v的出度是指以该顶点为弧尾的弧的数目，记为OD (v)。
权：是指对边赋予的有意义的数值量。
网：边上带权的图，也称网图。
回路（环）：第一个顶点和最后一个顶点相同的路径。
简单路径：序列中顶点不重复出现的路径。
简单回路（简单环）：除了第一个顶点和最后一个顶点外，其余顶点不重复出现的回路。
子图：若图G=（V，E），G'=（V'，E'），如果V'V 且E'  E ，则称图G'是G的子图。
连通图：在无向图中，如果从一个顶点vi到另一个顶点vj(i≠j)有路径，则称顶点vi和vj是连通的。如果图中任意两个顶点都是连通的，则称该图是连通图。
连通分量：非连通图的极大连通子图称为连通分量。
强连通图：在有向图中，对图中任意一对顶点vi和vj (i≠j)，若从顶点vi到顶点vj和从顶点vj到顶点vi均有路径，则称该有向图是强连通图。
强连通分量：非强连通图的极大强连通子图。
生成树：n个顶点的连通图G的生成树是包含G中全部顶点的一个极小连通子图。
生成森林：在非连通图中，由每个连通分量都可以得到一棵生成树，这些连通分量的生成树就组成了一个非连通图的生成森林。
（二）图的便利操作
图的遍历是从图中某一顶点出发，对图中所有顶点访问一次且仅访问一次。 （是抽象操作，可以是对结点进行的各种处理，这里简化为输出结点的数据）

1. 深度优先遍历 （DFS：Depth First Search）
基本思想：
⑴ 访问顶点v；
⑵ 从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；
⑶ 重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。
2.广度优先遍历 （BFS：Broad First Search ；FIFO: First In First Out）
基本思想：
⑴ 访问顶点v；
⑵ 依次访问v的各个未被访问的邻接点v1, v2, …, vk；
⑶ 分别从v1，v2，…，vk出发依次访问它们未被访问的邻接点，并使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问。直至图中所有与顶点v有路径相通的顶点都被访问到。
（三）图的存储结构及实现
1.邻接矩阵（数组表示法）
基本思想：
用一个一维数组存储图中顶点的信息
用一个二维数组（称为邻接矩阵）存储图中各顶点之间的邻接关系。
1）无向图的邻接矩阵
特点：主对角线为 0 且一定是对称矩阵。
顶点的度：邻接矩阵的第i行（或第i列）非零元素的个数。
判断顶点 i 和 j 之间是否存在边：测试邻接矩阵中相应位置的元素arc[i][j]是否为1。
求顶点 i 的所有邻接点：将数组中第 i 行元素扫描一遍，若arc[i][j]为1，则顶点 j 为顶点 i 的邻接点。
2）有向图的邻接矩阵
求顶点 i 的出度：邻接矩阵的第 i 行元素之和。
求顶点 i 的入度:邻接矩阵的第 i 列元素之和。
判断从顶点 i 到顶点 j 是否存在边:测试邻接矩阵中相应位置的元素arc[i][j]是否为1。
邻接矩阵存储无向图的类:
 

```cpp
const int MaxSize=10;
template <class T>
class Mgraph{
public:
MGraph(T a[ ], int n, int e );
~MGraph( )
void DFSTraverse(int v);
void BFSTraverse(int v);
……
private:
T vertex[MaxSize];
int arc[MaxSize][MaxSize];
int vertexNum, arcNum;
};
```

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

```cpp
template <class T>
MGraph::MGraph(T 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; //置有边标志
}
}
```

邻接矩阵中图的基本操作——深度优先遍历:
⑴ 访问顶点v；
⑵ 从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；
⑶ 重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。
递归定义
 

```cpp
int visited[MaxSize];
template <class T>
void MGraph::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 );
}
```

邻接矩阵中图的基本操作——广度优先遍历：
⑴ 访问顶点v；
⑵ 依次访问v的各个未被访问的邻接点v1, v2, …, vk；
⑶ 分别从v1，v2，…，vk出发依次访问它们未被访问的邻接点，并使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问。直至图中所有与顶点v有路径相通的顶点都被访问到。
 

```cpp
int visited[MaxSize];
template <class T>
void MGraph::BFSTraverse(int v){
front=rear=-1; //假设采用顺序队列且不会发生溢出
int Q[MaxSize]; cout<<vertex[v]; visited[v]=1; Q[++rear]=v;
while (front!=rear) {
v=Q[++front];
for (j=0; j<vertexNum; j++)
if (arc[v][j]==1 && visited[j]==0 ) {
cout<<vertex[j]; visited[j]=1; Q[++rear]=j;
}
}
}
```

邻接矩阵上的其他操作：

增加一个顶点：在存储顶点的一维数组中插入该顶点的信息 在邻接矩阵中插入一行、一列

删除一个顶点：在存储顶点的一维数组中删除该顶点的信息 在邻接矩阵中删除一行、一列

增加一条边：修改相应的矩阵元素的值

删除一条边：修改相应的矩阵元素的值

2.邻接表

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

邻接表有两种结点结构：顶点表结点和边表结点。

定义邻接表的结点：

struct ArcNode{   
      int adjvex; 
      ArcNode *next;
};

template <class T>
struct VertexNode{
      T vertex;
      ArcNode *firstedge;
};

邻接表存储有向图的类：

const int MaxSize=10;    //图的最大顶点数
template <class T>
class ALGraph
{    
   public:
       ALGraph(T a[ ], int n, int e);   
       ~ALGraph;    
       void DFSTraverse(int v);      
       void BFSTraverse(int v);      
   ………
  private:
       VertexNode adjlist[MaxSize];   
       int vertexNum, arcNum;       
};

邻接表中图的基本操作——构造函数：

template <class T>
ALGraph::ALGraph(T 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;
     }
}



   

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

template <class T>
void ALGraph::DFSTraverse(int v){        
    cout<<adjlist[v].vertex;  visited[v]=1;
    p=adjlist[v].firstedge;    
    while (p!=NULL)     {
        j=p->adjvex;
        if (visited[j]==0) DFSTraverse(j);
    p=p->next;           
    }
}

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

template <class T>
void ALGraph::BFSTraverse(int v){
   front=rear=-1;   
   cout<<adjlist[v].vertex;    visited[v]=1;   Q[++rear]=v;   
   while (front!=rear)  {
       v=Q[++front];    p=adjlist[v].firstedge;    
       while (p!=NULL)  {
            j= p->adjvex;
            if (visited[j]==0) {
                cout<<adjlist[j].vertex;  visited[j]=1; Q[++rear]=j;
            }
            p=p->next;
       }
    }
}

其他操作：

增删顶点 增加：顶点表中插入一个元素

删除：在顶点表中删除一个元素，同时在边表中删除相应的边 增删边<x, y> 如果是有向图，则在x的边表中增加/删除边； 如果是无向图，则还要在y的边表中增加/删除一条边。

3.十字链表：有向图的链式存储结构

边集数组：利用两个一维数组 一个数组存储顶点信息， 另外一个数组存储边及其权 数组分量包含三个域：边所依附的两个顶点，权值 各边在数组中的次序可以任意。

边集数组的实现：

Struct edge
{ 
    int i；
    int j;
    int weight;
}

将邻接矩阵转化成边集数组：

 edge edges[M];//边的数据结构类型的变量
 for ( i = 0; i < G->vexnum; i++) { 
	 for (j = 0; j <= G->vexnum; j++)  {
	    if (G->arc[i][j] == 1)   {
	  	    edges[k].begin = i;
  	  	    edges[k].end = j;
	          // edges[k].weight = G->arc[i][j];
               k++;
         }
     }
 }

二、最小生成树

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

（一）普里姆（Prim）算法

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

伪代码：

1. 初始化两个辅助数组lowcost（=arc[0][i]）和adjvex(=0)(0是始点)；
2. 输出顶点u0，将顶点u0加入集合U中；
3. 重复执行下列操作n-1次
   3.1 在lowcost中选取最短边(lowcost[k])，取对应的顶点序号k；
   3.2 输出顶点k和对应的权值；
   3.3 将顶点k加入集合U中（lowcost[k]=0）；
   3.4 调整数组lowcost和adjvex；

Void prime(MGraph G){
    for(int i=1;i<G.vertexNu;i++){
        lowcost[i]=G.arc[0][i];  adjvex[i]=0;
    }
    lowcost[0]=0;
    for(i=1;i<G.vertexNum;i+++){
        k=MinEdge(lowcost,G.vertexNum)
        cout<<K<<adjvex[k]<<lowcost[k];
        lowcost[k]=0;
       
       for(j=1;j<G.vertexNum;j++)
          if((G.arc[k][j]<lowcost[j]){
              lowcost[j]=G.arc[k][j];
              arcvex[j]=k;
           }
    }
}

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

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

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 在E中标记边(u，v)，使得(u，v)不参加后续最短边的选取；

Kruskal算法实现中的三个关键问题：

1.图的存储结构 ：

采用边集数组存储图。

2.如何判断一条边所依附的两个顶点在同一个连通分两中(并查集)： 定义Parent[i]数组。数组分量的值表示顶点i的双亲节点（初值为-1；）      当一条边（u,v）的两个顶点的根结不同时，这两个结点属于不同的连通分量（利用parent 数组查找一棵树的根节点。当一个结点n的parent==-1，树的根节点即为n）

3.   如何将一条边所依附的两个顶点合并到同一个连通分量中       要进行联通分量的合并 ，其中一个顶点所在的树的根节点为vex1，另一个顶点所在的树的根节点为vex2，则：parent[vex2]=vex1；

三、最短路径

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

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

Dijkstra算法：

基本思想：

1.设置一个集合S存放已经找到最短路径的顶点，S的初始状态只包含源点v，

2. 对vi∈V-S，假设从源点v到vi的有向边为最短路径（从v到其余顶点的最短路径的初值）。

3. 以后每求得一条最短路径v, …, vk，就将vk加入集合S中，并将路径v, …, vk , vi与原来的假设相比较，取路径长度较小者为最短路径。

重复上述过程，直到集合V中全部顶点加入到集合S中。

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

四、 有向无环图及其应用

（一）AOV网

AOV网：在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，称这样的有向图为顶点表示活动的网，简称AOV网。

特点：

1.AOV网中的弧表示活动之间存在的某种制约关系。

2.AOV网中不能出现回路 。

拓扑序列：

基本思想： ⑴ 从AOV网中选择一个没有前驱的顶点并且输出； ⑵ 从AOV网中删去该顶点，并且删去所有以该顶点为尾的弧； ⑶ 重复上述两步，直到全部顶点都被输出，或AOV网中不存在没有前驱的顶点。

拓扑排序算法——伪代码：

1. 栈S初始化；累加器count初始化；
2. 扫描顶点表，将没有前驱的顶点压栈；
3. 当栈S非空时循环
       3.1 vj=退出栈顶元素；输出vj；累加器加1；
       3.2 将顶点vj的各个邻接点的入度减1；
       3.3 将新的入度为0的顶点入栈；
4. if (count<vertexNum) 输出有回路信息；

void TOpSort(){
int  top=-1, count=0;
for(int i=0;i<vertexnum;i++)
     if(adjlist[i].in==0) s[++top]=i;
while(top!=-1){
    j=s[top--]; cout <<adjlist[j].vertext;   count++;
    p=adjlist[j].firstedge;
    while(p!=NULL){
          k=p->adjvex; adjlist[k].in--;
         if(adjlist[k].in==0) s[top++]=k;
         p=p->next;
      } 
}
If (count<vertexNum) cout<<“有回路”；
}

AOE网

AOE网： 在一个表示工程的带权有向图中， 用顶点表示事件， 用有向边表示活动， 边上的权值表示活动的持续时间， 称这样的有向图叫做边表示活动的网，简称AOE网。 AOE网中没有入边的顶点称为始点（或源点），没有出边的顶点称为终点（或汇点）。

关键路径：在AOE网中，从始点到终点具有最大路径长度（该路径上的各个活动所持续的时间之和）的路径称为关键路径。

关键活动：关键路径上的活动称为关键活动。

⑴ 事件的最早发生时间ve[k]

ve[k]是指从始点开始到顶点vk的最大路径长度。这个长度决定了所有从顶点vk发出的活动能够开工的最早时间。

⑵ 事件的最迟发生时间vl[k]

vl[k]是指在不推迟整个工期的前提下,事件vk允许的最晚发生时间。

 ⑶ 活动的最早开始时间e[i]

若活动ai是由弧<vk , vj>表示，则活动ai的最早开始时间应等于事件vk的最早发生时间。因此，有：e[i]=ve[k]

⑷ 活动的最晚开始时间l[i]

活动ai的最晚开始时间是指，在不推迟整个工期的前提下， ai必须开始的最晚时间。 若ai由弧<vk，vj>表示， 则ai的最晚开始时间要保证事件vj的最迟发生时间不拖后。 因此，有：l[i]=vl[j]-len<vk, vj>