数据结构：图的存储and遍历

原创已于 2022-05-21 10:47:04 修改 · 527 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#广度优先搜索 #深度优先搜索 #邻接矩阵 / 邻接多重表 #邻接表 #十字链表

于 2019-06-02 15:23:45 首次发布

综合-数据结构和算法专栏收录该内容

19 篇文章

订阅专栏

本文详细介绍了图的基本概念，包括子图、完全图、稀疏图等，并阐述了图的存储结构如邻接矩阵、邻接表、十字链表及邻接多重表的特点与适用场景。此外，还深入探讨了图的遍历算法——深度优先搜索与广度优先搜索，分析了它们的时间复杂度及应用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、图的定义

子图：假设有两个图：G1=(V1,E1)，G2=(V2,E2)，如果V1属于V2，E1属于E2，则说：G1为G2的子图；
无向完全图：对于无向图，若其有n(n-1)/2条边，则称其为 “无向完全图”；
有向完全图：对于有向图，若其有n(n-1)条边，则称其为“有向完全图”；
稀疏图：有很少条边或弧的图称为“稀疏图”。反之则称为“稠密图”；
网：带权的图通常称为网；
入度：以顶点v为头的弧的数目；
出度：以顶点v为尾的弧的数目；
度：顶点v的入度 + 出度；
一般的，如果顶点v_i的度为TD(v_i)，那么有n个顶点，e条边的图，满足如下关系：e=1/2*sum(TD(v_i))，i=1,…,n；
路径长度：一条路径上经过的边或弧的数目；
回路/环：第一个顶点和最后一个顶点相同的路径称为回路/环；
简单路径：序列中顶点不重复出现的路径；
简单回路/简单环：除第一个顶点和最后一个顶点外，序列中顶点不重复出现的路径；
连通：在无向图G中，如果从顶点v到v’有路径，则称v和v’是连通的；
连通图：如果对于无向图G，任意两个顶点v和v’都是连通的，则称G为连通的；
连通分量：无向图中的极大连通子图；
强连通图：在有向图G中，对于任意两个顶点v和v’，如果从v到v’，和，从v’到v都存在路径，则称G为强连通图；
有向图的强连通分量：有向图中的极大强连通子图；
连通图的生成树：一个极小连通子图，它含有图中全部顶点，但只有足以构成一棵树的n-1条边，这样的连通子图称为连通图的生成树；
有向树：有一个顶点的入度为0，其余顶点的入度均为1的有向图称为有向树；
生成森林：一个有向图的生成森林是由若干棵有向树组成，含有图中全部顶点，但只有足以构成若干棵不相交的有向树的弧；

二、图的存储结构

1、邻接矩阵（Adjacency Matrix）

邻接矩阵：是表示顶点之间相邻关系的矩阵。

设G(V，E)是具有n个顶点的图，则G的邻接矩阵是具有如下性质的n阶方阵：
A[i][j] = 1 若<vi,vj>或<vj,vi>属于E
0 反之
若G是网，则邻接矩阵可以定义为：
A[i][j] = w_ij 若<vi,vj> 或 <vj,vi>属于E
无穷大反之
图的邻接矩阵表示：

#define MaxInt 32767
#define MVNum 100
typedef char VerTexType; //顶点的类型
typedef int ArcType; //弧的类型
typedef struct{
VerTexType vexs[MVNum]; //顶点表
ArcType arcs[MVNum][MVNum];  //邻接矩阵
int vernum,arcnum;  //顶点数，边数
}AMGraph;

邻接矩阵优缺点

优点	缺点
1、便于判断两个顶点之间是否有边，只要判断A[i][j]=0或1即可；	1、不便于增加和删除顶点；
2、便于计算一个顶点的度：只要遍历row=i的行(出度) 以及 column=i的列(入度)，即可求出度；	2、不便于统计边的数目，需要遍历真个邻接矩阵才能求出边的数目，时间复杂度为O(n²)；
	3、对于有向稀疏图来讲，存储时空间复杂度为O(n²)；对于无向图来讲，由于其邻接矩阵是对称的，所以对于大规模的邻接矩阵可以采用压缩存储的方法，仅存储下三角（或上三角）的元素，这样需要n(n-1)/2个单元即可；但无论有向/无向图，其存储空间复杂度均为O(n²)；
可以看出，邻接矩阵不适合存储稀疏图；

采用邻接矩阵表示法，创建无向图

Status CreateUDN(AMGraph &G){
  cin>>G.vexnum>>G.arcnum; //输入顶点数和边数；
  for(i=0;i<G.vexnum;++i){
    cin>>G.vexs[i];
  }
  for(i=0;i<G.vexnum;++i){
    for(j=0;j<G.vexnum;++j){
      G.arcs[i][j] = MaxInt;
    }
  }
  for(k=1;k<=G.arcnum;++k){
    cin>>v1>>v2>>w;
    i=LocateVex(G.vexs,v1);
    j=LocateVex(G.vexs,v2); //确定输入顶点 在 顶点表中的下标位置；
    G.arcs[i][j] = w;
    G.arcs[j][i] = G.arcs[i][j];
  }
  return OK;
}

//可以看出 用 邻接矩阵 构建无向图的时间复杂度为 O(n^2^)；

2、邻接表(Adjacency List)

邻接表是图的一种链式存储结构，在邻接表中，对图中每个顶点vi建立一个单链表，把与vi相邻接的顶点放在这个链表中。邻接表中每个单链表的第一个结点存放有关顶点的信息。把这一结点看成是链表的表头，其余结点存放有关边的信息。这样，邻接表由两部分组成：表头结点表和边表；

表头结点结构：
包含：数据 and 指向第一个边的指针

data	firstarc

边结构：
包含：邻接点 and 边信息 and 指向下一个边的指针

adjvex	info	nextarc

邻接表存储结构：

#define MVNum 100
typedef struct ArcNode{ //边结点
  int Adjvex;  //邻接点 index
  OtherInfo info; //边的信息
  struct ArcNode *nextarc;  //指向下一个边的指针
}ArcNode;
typedef struct VNode{  //表头结点 
  VexTexType data; //顶点数据
  ArcNode *firstarc;  //指向第一个边的指针
}VNode,AdjList[MVNum];
typedef struct ALGraph{
  AdjList vertices;  //表头结点 表
  int vexnum,arcnum; //顶点数 和 弧数
}ALGraph;

在无向图的邻接表中，顶点vi的度恰为第i个链表中的结点数；
而在有向图中，第i个链表中的结点数为顶点vi的出度，要求其入度，则需遍历整个邻接表；
如果想求有向图中某一顶点vi的入度，可以建立有向图的 “逆邻接表”，即：顶点vi的链表中存着所有进入vi的边；

采用邻接表表示法创建无向图

Status CreateUDG(ALGraph &G){
cin>>G.vexnum>>G.arcnum;
for(i=0;i<G.vexnum;++i){
  cin>>G.vertices[i].data;
  G.vertices[i].firstarc = NULL;
}
for(k=0;k<G.arcnum;++k){
  cin>>v1>>v2>>w; //输入边的信息，以及权重信息
  i = LocateVex(v1,G.vertices); //查找顶点在 表头结点表中的下标
  j = LocateVex(v2,G.vertices);
  p1 = new ArcNode;
  p1->AdjVex = j;
  p1->info = w;
  p1->nextarc = G.vertices[i].firstarc; 
  G.vertices[i].firstarc = p1;
  p2 = new ArcNode;
  p2->AdjVex = i;
  p2->info = w;
  p2->nextarc = G.vertices[j].firstarc;
  G.vertices[j].firstarc = p2;
}
return OK;
} 

//算法的时间复杂度为：O(n+e)   

//与邻接矩阵相比，邻接表 更适合存储 稀疏图

//值得注意的是：一个图的邻接矩阵表示是唯一的，但是 邻接表不是，因为，表头结点表中顶点次序不唯一，边表中边次序不唯一；

邻接表的优缺点：

优点	缺点
1、便于增加和删除操作；	1、不便于判断顶点之间是否有边，如要判断，需要遍历顶点vi的边表，最坏情况下，时间复杂度为O(n)
2、便于统计边的个数。只要遍历表头结点中所有边即可，时间复杂度为O(n+e)；	2、不便于判断有向图某顶点vi的度，如要判断，则需遍历vi的边表判断出度，遍历所有边表判断入度，时间复杂度为O(n+e)；对于无向图，则只需遍历顶点vi的边表，最坏情况下，时间复杂度为O(n)；
3、空间效率高：适用于稀疏图的存储，空间复杂度为O(n+e)。稠密图由于邻接表还要存储指针，所以邻接矩阵更适合稠密图的存储，空间复杂度为O(n²)；
十字链表有效解决了邻接表中求有向图顶点vi度的问题（邻接表只能透过顶点vi的边表求出vi的出度）。

3、十字链表(Orthogonal List)

十字链表是有向图的另一种链式存储结构。可以看成是将有向图的邻接表和逆邻接表结合起来得到的一种链表。在十字链表中，对应于有向图中每一条弧有一个结点，对应于有向图中每一个顶点有一个结点，其结构具体如下：

顶点结点结构
包括：数据域 and 指向以该顶点为弧头的第一条边的指针 and 指向以该顶点为弧尾的第一条边的指针

data	firstin	firstout

弧结点结构
包括：
尾域(tailvex)：指示弧尾在图中的位置；
头域(headvex)：指示弧头在图中的位置；
info：指示弧的相关信息；
链域tlink：指示下一条具有相同弧尾的弧的指针；
链域hlink：指示下一条具有相同弧头的弧的指针；

tailvex	headvex	hlink	tlink	info

有向图的十字链表存储表示

#define MA_VERTEX_NUM  200
typedef struct ArcBox{ //弧结点
InfoType *info;
int tailvex;
int headvex;
struct ArcBox *hlink;
struct ArcBox *tlink;
}ArcBox;
typedef struct VexNode{ //顶点结点
VextexType data;
ArcBox *firstin;
ArcBox *firstout;
}VexNode;
typedef struct{ //十字链表存储表示
VexNode xlist[MAX_VERTEX_NUM];
int vexnum,arcnum;
}OLGraph;

//建立十字链表的时间复杂度 和 建立邻接表的时间复杂度 是相同的，均为O(n+e)；
//在十字链表中 既容易找到顶点vi的出度，也容易找到其入度，因而容易求 顶点的度；

4、邻接多重表(Adjacency Multilist)

利用 “邻接表” 存储无向图时，如果要删除无向图中的某条边，则需同时到表头结点表中对vi，vj的边表进行操作，比较麻烦。
而用 “邻接多重表” 存储无向图时，如果要删除无向图中某一条边，则只需对一个边结点进行操作即可。
邻接多重表包含两个部分：一个为顶点结点，一个为边结点，二者结构具体如下：

顶点结点结构
包括：数据域 and 指向依赖于这个顶点的第一条边的指针

data	firstedge

边结点结构
包括：mark(标记边是否被遍历) and ivex(顶点i index) and ilink(指向依赖于这个顶点的边的指针) and jvex(顶点j index) and jlink(指向依赖于这个顶点的边的指针) and info(边的信息)

mark	ivex	ilink	jvex	jlink	info

邻接多重表的存储结构

#define MAX_VEXTEX_NUM 80
typedef enum{unvisited,visited} VisitIf; //定义标志域 数据类型
typedef struct EBox{  //边结点
  VisitIf mark;
  int ivex;
  struct EBox *ilink;
  int jvex;
  struct EBox *jlink;
  InfoType *info;
}EBox;
typedef struct VexBox{  //顶点结点
  VextexType data;
  EBox *firstedge;
}VexBox;
typedef struct{  //邻接多重表
  VexBox vertices[MAX_VERTEX_NUM];
  int vexnum,arcnum;
}AMLGraph;

//由于邻接表存储边需要涉及两个结点，而邻接多重表一个边结点中同时包含两个结点，因此，邻接多重表 和 邻接表 所需的存储量相同；

总结：可用于存储无向图和有向图的存储表示：

无向图	有向图
邻接矩阵	邻接表
邻接表	十字链表
邻接多重表

三、图的遍历

1、深度优先搜索(Depth First Search)

深度优先搜索类似于树的先序遍历(parent->child：即先结点->其邻接点)。为递归过程。

1.1 深度优先搜索遍历图

bool visited[MVNUM]; //设定各个顶点初始访问状态为false
void DFS(Graph G,int v){
  cout<<v;
  visited[v] = true;
  for(w = FirstAdjVex(G,v);w>=0;w=NextAdjVex(G,v,w)){
    if(!visited[w]){DFS(G,w);} //如果w未被访问，访问w；
  }
}

//FirstAdjVex()和NextAdjVex()的求解方式，根据G的存储方式的不同而不同；

如果图为非连通图，则调用一次DFS()只能遍历一个连通分量；下面给出遍历一个非连通图的code；

1.2 深度优先遍历非连通图

void DFSTraverse(Graph G){
  for(v=0;v<G.vexnum;++v){visited[v]=false;}
  for(v=0;v<G.vexnum;++v){
    if(!visited[v]){DFS(G,v);}
  }
}

1.3 邻接矩阵 and 邻接表存储方式下的深度优先搜索(具体存储方式下的DFS())

邻接矩阵

for(v=0;v<G.vexnum;++v){visited[v] = false;}
void DFS_AM(Graph G,int v){ 
  cout<<v;
  visited[v] = true;
  for(w=0;w<G.vexnum;++w){
    if(G[v][w]){
      if(!visited[w]){DFS_AM(G,w);}
    }
  }

邻接表

for(v=0;v<G.vexnum;++v){visited[v]=false;}
void DFS_AL(Graph G,int v){ 
  cout<<v;
  visited[v]=true; 
  p = G.vertices[v].firstarc;
  while(p){
    w = p->AdjVex;
    if(!visited[w]){DFS_AL(G,w);}
    p = p->nextarc;
  }
}

总结：
1、使用深度优先搜索遍历图，其实质是查找每个顶点的邻接点的过程，因此，其时间复杂度为遍历每个顶点的邻接点的时间复杂度。用邻接矩阵存储图，其时间复杂度为O(n²)；用邻接表存储图，其时间复杂度为O(n+e)；
2、使用深度优先搜索的方式，可以判断图中是否有环；（拓扑排序也可以判断图中是否有环）；
3、当图为非连通图时，需要多次调用深度优先搜索方可遍历图中所有顶点；

2、广度优先搜索(Breadth First Search)

广度优先搜索类似于树的按层次遍历。为非递归过程。使用队列实现。

//利用广度优先搜素 遍历图
for(v=0;v<G.vexnum;++v){visited[v]=false;}
void BFS(Graph G,int v){
  InitQueue(Q); //初始化一个队列
  EnQueue(Q,v); //将v入队
  while(Q){
    DeQueue(Q,u);
    cout<<u; //输出 开始顶点v
    visited[u]=true;
    for(w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w)){
      if(!visited[w]){cout<<w;visited[w]=true;} //遍历u的所有邻接点；
      EnQueue(Q,w); //将u的 邻接点 进队列；
    }
  }
}

总结：
1、使用广度优先搜索遍历图，其实质相当于遍历每个顶点的邻接点，使用不同的存储方式存储图，遍历顶点邻接点的时间复杂度不同。如果使用邻接矩阵存储图，则广度优先搜索时间复杂度为O(n²)。如果使用邻接表存储图，则广度优先搜索时间复杂度为O(n+e)；
广度优先搜索和深度优先搜索的时间复杂度相同，都等于遍历顶点邻接点的时间复杂度；
2、如果图为非连通图，则需要多次调用BFS()才能完成图的遍历，这一点与DFS()也相同。