数据结构(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)邻接表存储的基本思想:对于图的每个顶点vi,将所有邻接于vi的顶点链成一个单链表,称为顶点vi的边表(对于有向图则称为出边表),所有边表的头指针和存储顶点信息的一维数组构成了顶点表。
(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={u0}(u0∈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)输出顶点u0,将顶点u0加入集合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,对vi∈V-S,假设从源点v到vi的有向边为最短路径。以后每求得一条最短路径v, …, vk,就将vk加入集合S中,并将路径v, …, vk , vi与原来的假设相比较,取路径长度较小者为最短路径。重复上述过程,直到集合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 将顶点vk添加到数组s中;
(二)数据结构 :
1、图的存储结构:带权的邻接矩阵存储结构
2、数组dist[n]:每个分量dist[i]表示当前所找到的从始点v到终点vi的最短路径的长度。初态为:若从v到vi有弧,则dist[i]为弧上权值;否则置dist[i]为∞。
3、数组path[n]:path[i]是一个字符串,表示当前所找到的从始点v到终点vi的最短路径。初态为:若从v到vi有弧,则path[i]为vvi;否则置path[i]空串。
4、数组s[n]:存放源点和已经生成的终点,其初态为只有一个源点v。
(三)Floyd算法
1、基本思想:对于从vi到vj的弧,进行n次试探:首先考虑路径vi,v0,vj是否存在,如果存在,则比较vi,vj和vi,v0,vj的路径长度,取较短者为从vi到vj的中间顶点的序号不大于0的最短路径。在路径上再增加一个顶点v1,依此类推,在经过n次比较后,最后求得的必是从顶点vi到顶点vj的最短路径。
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];
}
}