数据结构——图知识总结
一、图的逻辑结构
1、图的定义
图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：
G=(V，E)
其中：G表示一个图，V是图G中顶点的集合，E是图G中顶点之间边的集合。
在线性表中，元素个数可以为零，称为空表；
在树中，结点个数可以为零，称为空树；
在图中，顶点个数不能为零，但可以没有边。
2、不同结构中逻辑关系的对比
在线性结构中，数据元素之间仅具有线性关系；
在树结构中，结点之间具有层次关系；
在图结构中，任意两个顶点之间都可能有关系。
二、图的基本术语
简单图：在图中，若不存在顶点到其自身的边，且同一条边不重复出现。
邻接、依附：
无向图中，对于任意两个顶点vi和顶点vj，若存在边(vi，vj)，则称顶点vi和顶点vj互为邻接点，同时称边(vi，vj)依附于顶点vi和顶点vj。
有向图中，对于任意两个顶点vi和顶点vj，若存在弧<vi，vj>，则称顶点vi邻接到顶点vj，顶点vj邻接自顶点vi，同时称弧<vi，vj>依附于顶点vi和顶点vj 。
无向完全图：在无向图中，如果任意两个顶点之间都存在边，则称该图为无向完全图。
有向完全图：在有向图中，如果任意两个顶点之间都存在方向相反的两条弧，则称该图为有向完全图。
含有n个顶点的无向完全图有n×(n-1)/2条边。
含有n个顶点的有向完全图有n×(n-1)条边。
稀疏图：称边数很少的图为稀疏图；
稠密图：称边数很多的图为稠密图。
顶点的度：在无向图中，顶点v的度是指依附于该顶点的边数，通常记为TD (v)。
顶点的入度：在有向图中，顶点v的入度是指以该顶点为弧头的弧的数目，记为ID (v)；
顶点的出度：在有向图中，顶点v的出度是指以该顶点为弧尾的弧的数目，记为OD (v)。
具有n个顶点、e条边的无向图G中，各顶点的度之和与边数之和的关系？
在具有n个顶点、e条边的有向图G中，各顶点的入度之和与各顶点的出度之和的关系？与边数之和的关系？
权：是指对边赋予的有意义的数值量。
网：边上带权的图，也称网图。
路径：在无向图G=(V, E)中，从顶点vp到顶点vq之间的路径是一个顶点序列(vp=vi0,vi1,vi2, …, vim=vq)，其中，(vij-1,vij)∈E（1≤j≤m）。若G是有向图，则路径也是有方向的，顶点序列满足<vij-1,vij>∈E。
V1 到V4的路径： V1 V4
V1 V2 V3 V4
V1 V2 V5V3 V4
一般情况下，图中的路径不惟一。
V1 V4：长度为8
V1 V2 V3 V4 ：长度为7
V1 V2 V5V3 V4 ：长度为15
回路（环）：第一个顶点和最后一个顶点相同的路径。
简单路径：序列中顶点不重复出现的路径。
简单回路（简单环）：除了第一个顶点和最后一个顶点外，其余顶点不重复出现的回路。
子图：若图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中全部顶点的一个极小连通子图。
极小连通子图：有n-1条边，多——构成回路，少——不连通。
生成森林：在非连通图中，由每个连通分量都可以得到一棵生成树，这些连通分量的生成树就组成了一个非连通图的生成森林。
三、图的抽象数据类型定义
ADT Graph
Data
顶点的有穷非空集合和边的集合
Operation
InitGraph
前置条件：图不存在
输入：无
功能：图的初始化
输出：无
后置条件：构造一个空的图
DFSTraverse
前置条件：图已存在
输入：遍历的起始顶点v
功能：从顶点v出发深度优先遍历图
输出：图中顶点的一个线性排列
后置条件：图保持不变
BFSTraverse
前置条件：图已存在
输入：遍历的起始顶点v
功能：从顶点v出发广度优先遍历图
输出：图中顶点的一个线性排列
后置条件：图保持不变
DestroyGraph
前置条件：图已存在
输入：无
功能：销毁图
输出：无
后置条件：释放图所占用的存储空间
GetVex
前置条件：图已存在
输入：顶点v
功能：在图中查找顶点v的数据信息
输出：顶点v的数据信息
后置条件：图保持不变
endADT
三、图的遍历操作
从图中某一顶点出发，对图中所有顶点访问一次且仅访问一次。
①选取遍历的起始顶点：从编号小的顶点开始 。
为了定义操作的方便，将图中的顶点按任意顺序排列起来，比如，按顶点的存储顺序。
②从某个起点始可能到达不了所有其它顶点：多次调用从某顶点出发遍历图的算法。
③因图中可能存在回路，某些顶点可能会被重复访问，那么如何避免遍历不会因回路而陷入死循环?
解决方案：附设访问标志数组visited[n] 。
④在图中，一个顶点可以和其它多个顶点相连，当这样的顶点访问过后，如何选取下一个要访问的顶点？
解决方案：深度优先遍历和广度优先遍历。
1、深度优先遍历
基本思想 ：
⑴ 访问顶点v；
⑵ 从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；
⑶ 重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。
回溯方法
2、广度优先遍历
基本思想：
⑴ 访问顶点v；
⑵ 依次访问v的各个未被访问的邻接点v1, v2, …, vk；
⑶ 分别从v1，v2，…，vk出发依次访问它们未被访问的邻接点，并使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问。直至图中所有与顶点v有路径相通的顶点都被访问到。
四、图的存储结构及实现
邻接矩阵
有向图和无向图
邻接表
有向图（出边表）和无向图
逆邻接表（有向图的入边表）
有向图，方便计算顶点的入度
有向图的十字链表
无向图的邻接多重表
边集数组
邻接矩阵（数组表示法）
基本思想：
用一个一维数组存储图中顶点的信息
用一个二维数组（称为邻接矩阵）存储图中各顶点之间的邻接关系。
假设图G＝(V，E)有n个顶点，则邻接矩阵是一个n×n的方阵，定义为：
1、向图的邻接矩阵：主对角线为 0 且一定是对称矩阵。
①如何判断顶点 i 和 j 之间是否存在边？
测试邻接矩阵中相应位置的元素arc[i][j]是否为1。
②如何求顶点 i 的所有邻接点？
将数组中第 i 行元素扫描一遍，若arc[i][j]为1，则顶点 j 为顶点 i 的邻接点。
2、有向图的邻接：
①有向图的邻接矩阵一定不对称吗？
不一定，例如有向完全图。
②如何求顶点 i 的入度？
邻接矩阵的第 i 列元素之和。
③如何判断从顶点 i 到顶点 j 是否存在边？
测试邻接矩阵中相应位置的元素arc[i][j]是否为1。
3、网图的邻接矩阵
网图的邻接矩阵可定义为：
五、图的存储结构及实现
矩阵：
1、类
const int MaxSize=10;
template
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;
};
2、构造函数
template
MGraph::MGraph(T a[ ], int n, int e) {
vertexNum=n; arcNum=e;
for (i=0; i
vertex[i]=a[i];
for (i=0; i
for (j=0; j
arc[i][j]=0;
for (k=0; k
cin>>i>>j; //边依附的两个顶点的序号
arc[i][j]=1; arc[j][i]=1; //置有边标志
}
}
3、深度优先遍历：
int visited[MaxSize];
template
void MGraph::DFSTraverse(int v){
cout<
for (j=0; j
if (arc[v][j]==1 && visited[j]==0)
DFSTraverse( j );
}
4、广度优先遍历
int visited[MaxSize];
template
void MGraph::BFSTraverse(int v){
front=rear=-1; //假设采用顺序队列且不会发生溢出
int Q[MaxSize]; cout<
while (front!=rear) {
v=Q[++front];
for (j=0; j
if (arc[v][j]==1 && visited[j]==0 ) {
cout<
}
}
}
5、增加一个顶点
template
void MGraph
if ( num<0|| num>vertexNum) throw "位置";
int row, col, numv;
numv = vertexNum-1;
vertexNum++;
for(int i=numv;i>=num;i--) vertex[i++]=vertex[i];
vertex[num]=name;
for(row=numv;row>=0;row--) {所有行上num列之后的列后移，增加一列，
for(col=numv;col>=num;col--) arc[row][col+1]=arc[row][col];
arc[row][num]=0;
}
for(row=numv;row>=num;row--)
for(col=0;col<=numv+1;col++) arc[row+1][col]=arc[row][col];
for(col=0;col
}
6、删除一个顶点
template
if ( pos<0|| pos>MaxSize) throw "位置";
int row， col;
int numv=vertexNum;
for(int i=pos;i
vertexNum--;
for(row=0;row
for(col=pos;col
}
for(row=pos;row
for(col=0;col
arc[row][col]=arc[row+1][col];
}
}
7、插入一条边
tmplate
void MGraph
{
if ( i>MaxSize|| j>MaxSize) throw "位置";
arc[i][j]=1;
arc[j][i]=1;
}
8、删除一条边
template
void MGraph
{
if ( i>MaxSize|| j>MaxSize) throw "位置";
arc[i][j]=arc[j][i]=0;
}
邻接表
邻接表存储的基本思想：
对于图的每个顶点vi，将所有邻接于vi的顶点链成一个单链表，称为顶点vi的边表（对于有向图则称为出边表）
所有边表的头指针和存储顶点信息的一维数组构成了顶点表。
邻接表有两种结点结构：顶点表结点和边表结点。
vertex：数据域，存放顶点信息。
firstedge：指针域，指向边表中第一个结点。
adjvex：邻接点域，边的终点在顶点表中的下标。
next：指针域，指向边表中的下一个结点。
1、定义邻接表的结点 ：
struct ArcNode{
int adjvex;
ArcNode *next;
};
template
struct VertexNode{
T vertex;
ArcNode *firstedge;
};
2、无向图的邻接表：
边表中的结点表示每个结点对应图中的一条边，邻接表的空间复杂度为O(n+e)。
顶点 i 的度：顶点i的边表中结点的个数。
判断顶点 i 和顶点 j之间是否存在边：测试顶点 i 的边表中是否存在终点为 j 的结点。
3、有向图的邻接表：
求顶点 i 的出度：顶点 i 的出边表中结点的个数。
求顶点 i 的入度：各顶点的出边表中以顶点 i 为终点的结点个数。
求顶点 i 的所有邻接点：遍历顶点 i 的边表，该边表中的所有终点都是顶点 i 的邻接点。
4、有向图类
const int MaxSize=10; //图的最大顶点数
template
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
ALGraph::ALGraph(T a[ ], int n, int e)
{
vertexNum=n; arcNum=e;
for (i=0; i
{
adjlist[i].vertex=a[i];
adjlist[i].firstedge=NULL;
}
for (k=0; k
{
cin>>i>>j;
s=new ArcNode; s->adjvex=j;
s->next=adjlist[i].firstedge;
adjlist[i].firstedge=s;
}
}
深度优先遍历：
template
void ALGraph::DFSTraverse(int v){
cout<
p=adjlist[v].firstedge;
while (p!=NULL) {
j=p->adjvex;
if (visited[j]==0) DFSTraverse(j);
p=p->next;
}
}
广度优先遍历：
template
void ALGraph::BFSTraverse(int v){
front=rear=-1;
cout<
while (front!=rear) {
v=Q[++front]; p=adjlist[v].firstedge;
while (p!=NULL) {
j= p->adjvex;
if (visited[j]==0) {
cout<
}
p=p->next;
}
}
}
十字链表：有向图的链式存储结构
vertex：数据域，存放顶点信息；
firstin：入边表头指针；
firstout：出边表头指针；
tailvex：弧的起点在顶点表中的下标；
headvex：弧的终点在顶点表中的下标；
headlink：入边表指针域；
taillink：出边表指针域。
邻接多重表 ：无向图的存储结构
边集数组
利用两个一维数组
数组分量包含三个域：边所依附的两个顶点，权值
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++;
}
}
}
六、普里姆（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。
Void prime(MGraph G){
for(int i=1;i
lowcost[i]=G.arc[0][i]; adjvex[i]=0;
}
lowcost[0]=0;
for(i=1;i
k=MinEdge(lowcost,G.vertexNum)
cout<
lowcost[k]=0;
for(j=1;j
if((G.arc[k][j]
lowcost[j]=G.arc[k][j];
arcvex[j]=k;
}
}
}
克鲁斯卡尔（Kruskal）算法
基本思想：
. 初始化：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算法实现中的三个关键问题：
采用边集数组存储图。
定义Parent[i]数组。数组分量的值表示顶点i的双亲节点（初值为-1；）
当一条边（u,v）的两个顶点的根结不同时，这两个结点属于不同的连通分量（利用parent 数组查找一棵树的根节点。当一个结点n的parent==-1，树的根节点即为n）
3、如何将一条边所依附的两个顶点合并到同一个连通分量中
要进行联通分量的合并 ，其中一个顶点所在的树的根节点为vex1，另一个顶点所在的树的根节点为vex2，则：parent[vex2]=vex1；
并查集的存储结构：
用树结构(双亲表示法)实现并查集。
int main(){
int arcNum, int vertexNum;
EdgeNode *edge;
int *parent;
cout<<"please input the number of vertexNum:"; cin>>vertexNum;
cout<<"please input the number of edges:"; cin>>arcNum;
edge=new EdgeNode[arcNum]; parent=new int[vertexNum];
for(int i=0;i
cout<<"Please input the edges:";
cin>>edge[i].from>>edge[i].to>>edge[i].weight;
}
sort(edges, G); //对边集数组进行堆排序，时间复杂性为O(eloge)
for (i=0;i
parent[i]=-1; //每个节点分属于不同的集合
int k=0,begin,end,count=0;
cout<<"next is the MST :"<
for (k=0;k
begin=edge[k].from; end=edge[k].to;
int m,n;
m=Find(parent,begin); n=Find(parent,end);
if(m!=n) {
cout<
parent[n]=m;
count++;
if(count==vertexNum-1) break;
}
}
return 0;
}
int Find(int *parent, int node)
{
int f;
f=node;
while(parent[f]>-1)
f=parent[f];
return f;
}
最短路径：在非网图中，最短路径是指两顶点之间经历的边数最少的路径。
在网图中，最短路径是指两顶点之间经历的边上权值之和最短的路径。
Dijkstra算法：
基本思想：
重复上述过程，直到集合V中全部顶点加入到集合S中。
Floyd算法：
基本思想：
设图g用邻接矩阵法表示，
求图g中任意一对顶点vi、 vj间的最短路径。
（-1） 将vi到vj 的最短的路径长度初始化为(vi,vj)， 然后进行如下n次比较和修正：
（0） 在vi、vj间加入顶点v0，比较（vi, v0, vj）和(vi, vj)的路径的长度，取其中较短的路径作为vi到vj的且中间顶点号不大于0的最短路径。
（1） 在vi、vj间加入顶点v1，
得（vi, …，v1）和(v1, …，vj)，其中：
（vi, …, v1）是vi到v1 的且中间顶点号不大于0的最短路径，
(v1, …, vj) 是v1到vj 的且中间顶点号不大于0的最短路径，
这两条路径在上一步中已求出。
将（vi, …, v1, …, vj）与上一步已求出的且vi到vj 中间顶点号不大于0的最短路径比较，取其中较短的路径作为vi到vj 的且中间顶点号不大于1的最短路径。
（2）在vi、vj间加入顶点v2，得
（vi, …, v2）和(v2, …, vj)， 其中：
（vi, …, v2）是vi到v2 的且中间顶点号不大于1的最短路径，
(v2, …, vj) 是v2到vj 的且中间顶点号不大于1的最短路径，
这两条路径在上一步中已求出。
将（vi, …, v2, …, vj）与上一步已求出的且vi到vj 中间顶点号不大于1的最短路径比较， 取其中较短的路径作为vi到vj 的且中间顶点号不大于2的最短路径。
……
void Floyd(MGraph G)
{
for (i=0; i
for (j=0; 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
for (i=0; i
for (j=0; j
if (dist[i][k]+dist[k][j]
dist[i][j]=dist[i][k]+dist[k][j];
path[i][j]=path[i][k]+path[k][j];
}
}
七、有向无环图及其应用
AOV网：
AOV网：在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，称这样的有向图为顶点表示活动的网，简称AOV网。
AOV网特点：
AOV网中的弧表示活动之间存在的某种制约关系。
AOV网中不能出现回路 。
拓扑排序：
拓扑序列：
设G=(V，E)是一个具有n个顶点的有向图，V中的顶点序列v1, v2, …, vn称为一个拓扑序列，当且仅当满足下列条件：若从顶点vi到vj有一 条路径，则在顶点的拓扑序列中顶点vi必在顶点vj之前。
拓扑排序：对一个有向图构造拓扑序列的过程称为拓扑排序 。
拓扑序列使得AOV网中所有应存在的前驱和后继关系都能得到满足。
基本思想：
⑴ 从AOV网中选择一个没有前驱的顶点并且输出；
⑵ 从AOV网中删去该顶点，并且删去所有以该顶点为尾的弧；
⑶ 重复上述两步，直到全部顶点都被输出，或AOV网中不存在没有前驱的顶点。
void TOpSort(){
int top=-1, count=0;
for(int i=0;i
if(adjlist[i].in==0) s[++top]=i;
while(top!=-1){
j=s[top--]; cout <
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
}
AOE网：
在一个表示工程的带权有向图中，
用顶点表示事件，
用有向边表示活动，
边上的权值表示活动的持续时间，
称这样的有向图叫做边表示活动的网，简称AOE网。
AOE网中没有入边的顶点称为始点（或源点），没有
AOE网的性质：
⑴ 只有在某顶点所代表的事件发生后，从该顶点出发的各活动才能开始；
⑵ 只有在进入某顶点的各活动都结束，该顶点所代表的事件才能发生。
出边的顶点称为终点（或汇点）。
八、图的连通性
无向图的连通性：
要想判定一个无向图是否为连通图，或有几个连通分量，通过对无向图遍历即可得到结果。
连通图：仅需从图中任一顶点出发，进行深度优先搜索（或广度优先搜索），便可访问到图中所有顶点。