第 6章 图——数据结构

1.图的定义

图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：   G=(V，E)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

路径长度：    非带权图——路径上边的个数              带权图——路径上各边的权之和

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

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

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

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

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

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

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

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

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

2.图的抽象数据类型定义

ADT  Graph

Data

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

Operation

InitGraph 功能：图的初始化

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

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

DestroyGraph 功能：销毁图

GetVex   功能：在图中查找顶点v的数据信息

   endADT

3.图的遍历操作——图的遍历是从图中某一顶点出发，对图中所有顶点访问一次且仅访问一次。

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

 

• 在线性表中，数据元素在表中的编号就是元素在序列中的位置，因而其编号是唯一的；
• 在树中，将结点按层序编号，由于树具有层次性，因而其层序编号也是唯一的；
• 在图中，任何两个顶点之间都可能存在边，顶点是没有确定的先后次序的，所以，顶点的编号不唯一。
• 为了定义操作的方便，将图中的顶点按任意顺序排列起来，比如，按顶点的存储顺序。

        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有路径相通的顶点都被访问到。

4.图的存储结构及实现

邻接矩阵（数组表示法）

基本思想：

用一个一维数组存储图中顶点的信息

用一个二维数组（称为邻接矩阵）存储图中各顶点之间的邻接关系。

邻接矩阵中图的基本操作——构造函数      MGraph(T a[ ], int n, int e );

1.确定图的顶点个数和边的个数； 2. 输入顶点信息存储在一维数组vertex中； 3. 初始化邻接矩阵； 4. 依次输入每条边存储在邻接矩阵arc中；

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

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

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

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;  //置有边标志   

    }

5.

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

⑴ 访问顶点v；

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

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

递归定义

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有路径相通的顶点都被访问到。

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;

            }

      }

}

邻接矩阵上的其他操作

增加一个顶点

在存储顶点的一维数组中插入该顶点的信息

在邻接矩阵中插入一行、一列

删除一个顶点

在存储顶点的一维数组中删除该顶点的信息

在邻接矩阵中删除一行、一列

增加一条边

修改相应的矩阵元素的值

删除一条边

修改相应的矩阵元素的值

6.

邻接表存储的基本思想：

对于图的每个顶点vi，将所有邻接于vi的顶点链成一个单链表，称为顶点vi的边表（对于有向图则称为出边表）

所有边表的头指针和存储顶点信息的一维数组构成了顶点表。

 

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

             顶点表                                      边   表

vertex：数据域，存放顶点信息。

firstedge：指针域，指向边表中第一个结点。

adjvex：邻接点域，边的终点在顶点表中的下标。

next：指针域，指向边表中的下一个结点。

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

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

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

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

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

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

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

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;     

    }

  

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

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;

    

8.图的存储结构

邻接矩阵

有向图和无向图

邻接表

有向图（出边表）和无向图

逆邻接表（有向图的入边表）

有向图，方便计算顶点的入度

有向图的十字链表

无向图的邻接多重表

边集数组

 

 

vertex：数据域，存放顶点信息；

firstin：入边表头指针；

firstout：出边表头指针；

tailvex：弧的起点在顶点表中的下标；

headvex：弧的终点在顶点表中的下标；

headlink：入边表指针域；

taillink：出边表指针域。

边集数组

利用两个一维数组

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

 

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

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

         }

     }

 }

图的存储结构的比较——邻接矩阵和邻接表

9.无向图的连通性——要想判定一个无向图是否为连通图，或有几个连通分量，通过对无向图遍历即可得到结果。

Ø连通图：仅需从图中任一顶点出发，进行深度优先搜索（或广度优先搜索），便可访问到图中所有顶点。

Ø非连通图：需从多个顶点出发进行搜索，而每一次从一个新的起始点出发进行搜索过程中得到的顶点访问序列恰为其各个连通分量中的顶点集。

求无向图的连通分量（非连通图的遍历方法）

1.count=0;

2.  for (图中每个顶点v)

       2.1 if (v尚未被访问过)

             2.1.1 count++;

             2.1.2 从v出发遍历该图（函数调用）；

3.  if (count==1) cout<<"图是连通的";

     else cout<<"图中有"<<count<<"个连通分量";

有向图的连通子图的求解过程

⑴ 从某顶点出发进行深度优先遍历，并按其所有邻接点都访问完（即出栈）的顺序将顶点排列起来。

⑵ 从最后完成访问的顶点出发，沿着以该顶点为头的弧作逆向的深度优先遍历。若不能访问到所有顶点，则从余下的顶点中最后访问的那个顶点出发，继续作逆向的深度优先遍历，直至有向图中所有顶点都被访问到为止。

生成树

结论：

•  由深度优先遍历得到的为深度优先生成树; 由广度优先遍历得到的为广度优先生成树。 
• 一个连通图的生成树可能不唯一，由不同的遍历次序、从不同顶点出发进行遍历都会得到不同的生成树。
•  对于非连通图，通过图的遍历，将得到的是生成森林。

最小生成树（minimal spanning tree）

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

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

10.普里姆（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。

Prim算法——伪代码

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;

           }

    }

}

11.克鲁斯卡尔（Kruskal）算法

基本思想：

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

Kruskal算法分析 1.初始化parent数组,定义计数器count（记录加入到生成树中的顶点的个数)； 2.对边集数组进行排序 3.依次考察边集数组中的每一条边（u，v）

     3.1确定u所在的树的根节点vex1;

     3.2确定v所在的树的根节点vex2;

     3.3 如果vex1!=vex2，则执行

         a. parent[vex2]=vex1;//将第一个节点的父亲设为第二个节点的父亲， 合并 为一个连通分量

            b. count++;

            c. 如果count==n-1,算法结束。

Kruskal算法的时间复杂性分析

边集数组排序，时间复杂性O（eloge）

在e条边中选边，时间复杂性为O(e)

因此时间复杂性为O（eloge）

12.最短路径 问题

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

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

单源点到其他顶点的最短路径        Dijkstra方法，O（n2）

任意一对顶点之间的最短路径        Floyed方法，O（n3）

路径长度递增的理解

含有n个顶点的图

计算图中顶点v到其他顶点（n-1个）的最短路

总共要找多少条最短路？

n-1条

按路径长度递增指的是这n-1条路的计算原则即，

先找第一条最短路（v，vi），所有n-1条路中最短的路

再找第二条最短路（v，vj）

。。。。。。

Dijkstra算法

基本思想：

1.设置一个集合S存放已经找到最短路径的顶点，S的初始状态只包含源点v， 2.对vi∈V-S，假设从源点v到vi的有向边为最短路径（从v到其余顶点的最短路径的初值）。 3.以后每求得一条最短路径v, …, vk，就将vk加入集合S中，并将路径v, …, vk , vi与原来的假设相比较，取路径长度较小者为最短路径。

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

Dijkstra算法——伪代码

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

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

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

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

     2.3 修改数组dist和path；

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

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

AOV网特点：1.AOV网中的弧表示活动之间存在的某种制约关系。2.AOV网中不能出现回路 。

拓扑序列：

设G=(V，E)是一个具有n个顶点的有向图，V中的顶点序列v1, v2, …, vn称为一个拓扑序列，当且仅当满足下列条件：若从顶点vi到vj有一条路径，则在顶点的拓扑序列中顶点vi必在顶点vj之前。

拓扑排序：对一个有向图构造拓扑序列的过程称为拓扑排序 。

拓扑序列使得AOV网中所有应存在的前驱和后继关系都能得到满足。

拓扑排序

基本思想：

⑴ 从AOV网中选择一个没有前驱的顶点并且输出；

⑵ 从AOV网中删去该顶点，并且删去所有以该顶点为尾的弧；

⑶ 重复上述两步，直到全部顶点都被输出，或AOV网中不存在没有前驱的顶点。

基于邻接表的拓扑排序的基本思想

（1）找G中无前驱的顶点

  查找indegree ［i］为零的顶点vi；

（2）修改邻接于顶点i的顶点的入度（删除以i为起点的所有弧）

  对链在顶点i后面的所有邻接顶点k，将对应的indegree［k］ 减1。

       为了避免重复检测入度为零的顶点，可以再设置一个辅助栈，若某一顶点的入度减为0，则将它入栈。每当输出某一入度为0的顶点时，便将它从栈中删除。

拓扑排序算法——伪代码

1. 栈S初始化；累加器count初始化；

2. 扫描顶点表，将没有前驱的顶点压栈；

3. 当栈S非空时循环

       3.1 vj=退出栈顶元素；输出vj；累加器加1；

       3.2 将顶点vj的各个邻接点的入度减1；

       3.3 将新的入度为0的顶点入栈；

4. if (count<vertexNum) 输出有回路信息；

AOE网：

在一个表示工程的带权有向图中，

用顶点表示事件，

用有向边表示活动，

边上的权值表示活动的持续时间，

称这样的有向图叫做边表示活动的网，简称AOE网。

AOE网中没有入边的顶点称为始点（或源点），没有出边的顶点称为终点（或汇点）。

AOE网的性质：

⑴ 只有在某顶点所代表的事件发生后，从该顶点出发的各活动才能开始；

⑵ 只有在进入某顶点的各活动都结束，该顶点所代表的事件才能发生。

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

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

 

 

 

 

 

• 点赞
• 收藏
• 分享
• 文章举报

路小舟!o 发布了13 篇原创文章 · 获赞 0 · 访问量 177 私信 关注