数据结构--图重点

一、定义与术语

图：无序数据结构

基本构成：1.边集（Edge ）：a. 有向图，有向边，弧，弧头，弧尾，权值

b. 无向图，无向边(v, w)，权值

2.顶点集（Vertices ）：a. 无向图：度(TD(v))

b. 有向图：出度(ID(v))，入度(OD(v))，度(TD(v) = ID(v) + OD(v))

无向完全图：n 个顶点，(1)2

n n -条边 有向完全图：n 个顶点，(1)n n -条边

网：带权图

连通分量：无向图中的极大连通子图（多个），无向完全图的连通分量就是本身（一个） 强连通分量：有向图中的极大连通子图，其中i v 到j v 以及j v 到i v 都有路径

生成树：图的极小连通子图，含有图的全部n 个顶点，只有n-1条边，少一条则不能连通，

多一条则形成回路

生成森林：不完全图中的各个连通分量的生成树，构成图的生成森林

二、存储结构

顶点：可采用链表或数组存储顶点列表，一般采用链表存储

边：1. 邻接矩阵（数组）

a. 无向图：对称阵，可采用矩阵压缩存储方式。A[i][j] = 0表示i v 和j v 没有连接；

A[i][j] = 1表示i v 和j v 有边连接；第i 行的和表示顶点i v 的度

b. 有向图：不对称阵。,[][]i j A i j w =表示顶点i v 到j v 的有向弧的权值；[][]A i j =∞

表示表示顶点i v 到j v 没有弧连接或者i = j

2. 邻接表（链表，有向无向都可用）

边结点：adjvex （邻接点），nextarc （下一条边），info （权值）

顶点结点：data （顶点数据），firstarc （第一条边）

3. 十字链表（Othogonal List ）

弧结点：tailvex （弧尾结点），headvex （弧头结点），tlink （弧尾相同的下一条弧），hlink

（弧头相同的下一条弧），info （权值）

顶点结点：data （顶点数据），firstin （第一条入弧），firstout （第一条出弧）

三、图的遍历（每个顶点只被访问一次）

1. 深度优先遍历（类似树的先根遍历）

基本思想：假设初始状态是图中所有顶点未曾被访问，则深度优先搜索可从图中某个顶

点v 出发，访问此结点，然后依次从v 的未被访问的邻接点出发深度优先遍

历图，直至图中所有和v 有路径相通的顶点都被访问到；若此时图中尚有顶

点未被访问（非连通图），则另选图中一个未曾被访问的顶点作起始点，重

复上述过程，直至图中所有顶点都被访问到为止。

代码：

void DFS(Graph& G, int v, bool first, bool visited[]) {

visit(getValue(G, v));

visited[v] = true;

int = getFirstNeighbor(G, v);

while(w != -1) {

if(!visited[w]) DFS(G, w, visited);

w = getNextNeighbor(G, v, w);

}

}

2. 广度优先搜索（类似于树的层次遍历）

基本思想：假设从图中某顶点v出发，在访问了v之后依次访问v的各个未曾访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使“先被访问的顶点

的邻接点”先于“后被访问的顶点的邻接点”被访问，直至图中所有已被访问的

顶点的邻接点都被访问到。若此时图中尚有顶点未被访问（非连通图），则另选图

中一个未曾被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问

到为止。

代码：

viod BFS(Graph& G, int v) {

int i, w, n = G.vexnum;

bool* visited = new bool[n];

for(i = 0; i < n; i++) visited[i] = false;

visit(getValue(G, v));

visited[v] = true;

Queue Q; initQueue(Q); enQueue(Q, v);

while (!isEmpty(Q)) {

deQueue(Q, v);

w = getFirstNeighbor(G, v);

while (w != -1) {

if (!visited[w]) {

visit(getValue(G, w));

enQueue(Q, w);

}

w = getNextNeighbor(G, v, w);

}

}

delete[] visited;

}

四、图的连通性问题（无向图）

1. 深度优先生成树（深度优先搜索形成），广度优先生成树（广度优先搜索形成）

深度优先生成森林算法：

void DFSForest(Graph G, CSTree& T) {

CSTree q = null;

int n = G.vexnum;

bool* visited = new bool[n];

for (int i = 0; i < n; i++) visited[i] = false;

for (int v = 0; v < n; v++) {

if (!visited[v]) {

CSTree p = (CSTree) malloc(sizeof(CSNode));

*p = {getValue(G, v), null, null};

if (T == null) T = p;

else q->nextSibling = p;

q = p;

DFSTree(G, v, p, visited);

}

}

}

深度优先生成树算法：

void DFSTree(Graph G, int v, CSTree T, bool& visited[]) {

visited[v] = true;

bool first = true;

CSTree q = null;

for (int w = getFirstNeighbor(G, v); w != -1; w = getNextNeighbor(G, v, w))

if (!visited[w]) {

CSTree p = (CSTree) malloc(sizeof(CSNode));

*p = {getValue(G, w), null, null};

if (first) {

T->lchild = p;

first = false;

}

else q->nextSibling = p;

q = p;

DFSTree(G, w, q, visited);

}

}

2. 最小生成树（Mini Cost Spanning Tree，MST）

定义：一棵生成树的代价就是树上各边的代价之和，最小生成树就是代价最小的生成树MST性质：假设N = (V, {E})是个连通网，U是顶点集V的一个非空子集。若(u, v)是一条具有最小权值（代价）的边，其中u∈U，v∈V-U，则必存在一棵包含边(u, v)的

最小生成树。

a. Prim 算法

基本思想：假设N = (V , {E})是连通网，TE 是N 上最小生成树中边的集合。算法从

00{}()U u u V =∈，{}TE =开始，重复执行下述操作：在所有u ∈U ，v ∈V-U

的边(u, v)∈E 中找一条代价最小的边00(,)u v 并入集合TE ，同时0v 并入U ，直

至U=V 为止。此时VE 必有n-1条边，则T=(V, {TE})为N 的最小生成树。为了

实现这个算法需要引入一个辅助数组closedge ，记录从U 到V-U 具有最小代价

的边。对每个顶点i v V U ∈-，在辅助数组中存在一个相应的分量

closedge[i-1]，它包括两个域，其中lowcost 存储该边上的权。显然

closedge[i-1].lowcost = Min{cost(u, i v )|u ∈U}。vex 域存储该边依附的在

U 中的顶点。

算法分析：时间复杂度2()O n ，与网中边数无关，适用于求边稠密的网的最小生成树。 代码：

void miniSpanTree_Prim(Graph G, VertexType u) {

int n = G.vexnum;

// gain vertex index

int k = locateVex(G, u);

// initialize auxiliary array

struct {

VertexType adjvex;

VRType lowcost;

} closedge[n];

for (int i = 0; i < n; i++)

if (i != k) closedge[i] = {u, G.arcs[k][j].adj};

closedge[k].lowcost = 0;

for (int i = 0; i < n; i++) {

// find the edge with minimum cost, and meanwhile,

// one vertex belongs to U, the other belongs to V-U

k = minimum(closedge);

// closedge[k].adjvex: u belongs to U

// G.vexs[k]: v belongs to V-U

printf(closedge[k].adjvex, G.vexs[k]);

// add v to U

closedge[k].lowcost = 0;

// modify closedge, reselect minimum edge

for (int j = 0; j < G.vexnum; j++)

if (G.arcs[k][j] < closedge[j].lowcost)

closedge[j] = { G.vexs[k], G.arcs[k][j].adj};

}

}

b. Kruskal算法

基本思想：假设连通网N = (V, {E})，则令最小生成树的初始状态为只有n个顶点而无边的非连通图T = (V, {})，图中每个顶点自成一个连通分量。在E中选择代价最小的

边，若该边依附的顶点落在T中不同的连通分量上（该条件保证了不可能产生

回路，可使用并查集的Find与Union函数实现），则将此边加入到T中，否则

舍去此边而选择下一条代价最小的边。依次类推，直至T中所有的顶点都在同

一连通分量上为止。

O e e（e为网中边的数目），适用于求边稀疏的网的最小生成树。算法分析：时间复杂度(log)

3. 关节点和重连通分量

关节点（割点）：假若在删去顶点v以及和v相关联的各边之后，将图的一个连通分量分割成两个或两个以上的连通分量，则称顶点v为该图的一个关节点。

重连通图：没有关节点的连通图称为重连通图。

连通度：若在连通图上至少删去k个顶点才能破坏图的连通性，则称此图的连通度为k。由此可知生成树的连通度为1。

关节点特性：a. 若生成树的根有多棵子树，则此根顶点必为关节点；

b. 若生成树中某个非叶子顶点v，其某棵子树的根和子树中的其他结点均没有

指向v的祖先的回边，则v为关节点。

五、有向无环图及其应用

1. 拓扑排序（工程能否顺利进行）

定义：由某个集合上的偏序得到该集合上的一个全序，偏序指集合中仅有部分成员之间可比较，而全序指集合中全体成员之间均可比较。

用途：一个表示偏序的有向图可用来表示一个流程图，图中每一条有向边表示两个子工程之间的次序关系（领先关系）。

AOV-网：用顶点表示活动，用弧表示活动间的优先关系的有向图称为顶点表示活动的网（Activity On Vertex Network），从顶点i到顶点j有一条有向路径，则i是j的前

驱，j是i的后继。

条件：在AOV-网中，不应该出现有向环，因为存在环意味着某项活动应以自己为先决条件。

检测的办法是对有向图构造其顶点的拓扑有序序列，若网中所有顶点都在它的拓

扑有序序列中，则该AOV-网中必定不存在环。

基本思想：a. 在有向图中选一个没有前驱的顶点且输出之

b. 从图中删除该顶点和所有以它为尾的弧

c. 重复上述两步，直至全部顶点均已输出（无环），或者当前图中不存在无前驱

的顶点为止（有环）。

代码：使用邻接表作为有向图的存储结构，使用辅助数组indegree存放每个顶点的入度，入度为0的顶点即为没有前驱的顶点，删除顶点及以它为尾的弧的操作，则可换以弧头顶点的入度减1来实现。

Status topologicalSort(Graph G) {

int i, n = G.vexnum;

int* indegree = new int[n];

findInDegree(G, indegree);

Stack S;

initStack(S);

for (i = 0; i < n; i++)

if (!indegree[i]) push(S, i);

int count = 0;

while (!isEmpty(s)) {

pop(S, i);

printf(i, G .vexs[i].data);

count++;

for (ArcNode p = G .vexs[i].firstArc; p; p = p->nextArc) {

int k = p->adjVex;

if (!(--indegree[k])) push(S, k);

}

}

if (count < n) return ERROR;

else return OK;

}

2. 关键路径（估算整个工程完成所必须的最短时间）

AOE-网：Activity On Edge ，是一个带权的有向无环图，其中，顶点表示事件（Event ），弧

表示活动，权表示活动持续的时间。

源点：在正常情况下（无环），网中只有一个入度为0的点，称作源点。

汇点：在正常情况下（无环），网中只有一个出度为0的点，称作汇点。

关键路径：完成工程的最短时间是从源点到汇点的最长路径的长度（活动持续时间最长），

整个最长路径就叫做关键路径。

最早发生/开始时间：假设源点是1v ，从1v 到i v 的最长路径长度叫做事件i v 的最早发生时间，

这个时间决定了所有以i v 为尾的弧所表示的活动的最早开始时间。

最迟发生/开始时间：这是在不推迟整个工程完成的前提下，活动i a 最迟必须开始进行的时

间。

时间余量：()()l i e i -，意味着完成活动i a 的时间余量。

关键活动：()()l i e i =的活动，关键路径上的所有活动都是关键活动，因此提前完成非关键

活动并不能加快工程的进度。

基本思想：如果活动i a 由弧表示，其持续时间记为dut()，则有如下关系：

弧：()()ee i ve i =，()()(,)el i vl k dut j k =-<>，

顶点：（1）从ve(0) = 0（源点）开始向前递推（拓扑有序）

(){()(,)},,,1,2,...,1i

ve j Max ve i dut i j i j T j n =+<><>∈=- 其中T 是所有以第j 个顶点为头的弧的集合

（2）从vl(n-1) = ve(n-1)（汇点）起向后递推（逆拓扑有序）

(){()(,)},,,2, 0

vl i Min vl j dut i j i j S i n =-<><>∈=- 其中S 是所有以第i 个顶点为尾的弧的集合

算法步骤：

（1）输入e 条弧，建立AOE-网的存储结构

（2）从源点0v 出发，令ve[0] = 0，按拓扑有序求其余各顶点的最早发生时间ve[i]（i ∈[1,

n-1]）。如果得到的拓扑有序序列中顶点个数小于网中顶点数n ，则说明网中存在环，不能求关键路径，算法终止；否则执行步骤（3）

（3）从汇点n v 出发，令vl[n-1] = ve[n-1]，按逆拓扑有序求其余各顶点的最迟发生时间vl[i]

（i ∈[n-2, 2]）

（4）根据各顶点的ve 值和vl 值，求每条弧s 的最早开始时间ee(s)和最迟开始时间el(s)。

若某条弧满足条件ee(s) = el(s)，则为关键活动

代码：

Status topologicalOrder(Graph G , Stack& T, int& *ve) {

int i, n = G.vexnum, count = 0;

int* indegree = new int[n];

findInDegree(G , indegree);

Stack S;

initStack(S);

for (i = 0; i < n; i++) {

if (!indegree[i]) push(S, i);

}

while (!isEmpty(S)) {

pop(S, i);

push(T, i);

count++;

for (ArcNode p = G .vexs[i].firstArc; p; p = p->nextArc) {

int k = p->adjVex;

if (!(--indegree[k])) push(S, k);

if (ve[i] + p->info > ve[k]) ve[k] = ve[i] + p->info;

}

}

if (count < n) return ERROR;

else return OK;

}

Status criticalPath(Graph G) {

int i, n = G.vexnum;

Stack T;

initStack(T);

int* ve = new int[n];

for (i = 0; i < n; i++) ve[i] = 0;

if (!topologicalOrder(G , T, ve) return ERROR;

int* vl = new int[n];

for (i = 0; i < n; i++) vl[i] = ve[n-1];

while (!isEmpty(T)) {

pop(T, i);

for (ArcNode p = G .vexs[i].firstArc; p; p = p->nextArc)

int k = p->adjVex;

if (vl[k] – p->info < vl[i]) vl[i] = vl[k] – p->info;

}

for (i = 0; i < n; i++)

for (ArcNode p = G .vexs[i].firstArc; p; p = p->nextArc) {

int k = p->adjVex;

int ee = ve[i];

int el = vl[k] – p->info;

tag = (ee == el) ? ‘*’ : ‘’;

printf(i, k, p->info,ee, el, tag);

}

}

算法分析：时间复杂度为()O n e -，只有在不改变网的关键路径的情况下，提高关键活动

的速度才有效。

六、最短路径（有向图）

1. 单源点最短路径问题

问题描述：给定带权有向图G 和源点v ，求从v 到G 中其余各顶点的最短路径。 算法描述：引进辅助向量D ，每个分量D[i]表示当前所找到的从源点v 到每个终点i v 的最短

路径长度。它的初态为：若从v 到i v 有弧，则D[i]为弧上的权值；否则置D[i]为∞。显然，长度为[]{[]|}i i

D j Min D i v V =∈的路径就是从v 出发的长度最短的一条最短路径，此路径为(,)j v v 。假设S 为已求得最短路径的终点的集合，则下一条最短路径（设其终点为x ）或者是弧(v, x)，或者是中间只经过S 中的顶点而最后到达顶点x 的路径，所以下一条长度次短的最短路径的长度必是

[]{[]|}i i

D j Min D i v V S =∈-，其中()D i 或者是弧(,)i v v 上的权值，或者是()()k D k v S ∈和弧(,)k i v v 上的权值之和。

算法步骤：

（1）假设用带权的邻接矩阵arcs 来表示带权有向图，arcs[i][j]表示弧,i j v v <>上的权值。

若,i j v v <>不存在，则置arcs[i][j]为∞（在计算机上可用允许的最大值代替）。S 为已

找到从v 出发的最短路径的终点的集合，它的初始状态为空集。那么，从v 出发到图上其余各顶点（终点）i v 可能达到的最短路径长度的初值为：[][(,)][],i D i a r c s L o c a t e V e x G v i v V

=∈ （2）选择j v ，使得[]{[]|}i D j Min D i v V S =∈-，其中j v 就是当前求得的一条从v 出发

的最短路径的终点。令{}S S j =

（3）修改从v 出发到集合V-S 上任一顶点k v 可达的最短路径长度。如果D[j] + arcs[j][k] <

D[k]，则修改D[k]为D[k] = D[j] + arcs[j][k]

（4）重复操作（2）、（3）共n-1次。由此求得从v 到图上其余各顶点的最短路径是依路径

长度递增的序列

Dijkstra 算法代码：

void shortestPath_Dij(Graph G , int v0, PathMatrix& P, ShortPathTable& D) {

// D: each element stores the shortest path that each vertex connects to v0

// P: if P[v][w] is true, that means the shortest path from v0 to v contains vertex w

// initialize P and D

for (v = 0; v < G .vexnum; v++) {

final[v] = false;

D[v] = G .arcs[v0][v];

for (w = 0; w < G .vexnum; w++) P[v][w] = false;

if (D[v] < INFINITY) {

P[v][v0] = true;

P[v][v] = true;

}

}

// start processing

D[v0] = 0;

final[v0] = true;

for (i = 1; i < G .vexnum; i++) {

min = INFINITY;

// get the nearest v that directly connects to v0

for (w = 0; w < G .vexnum; w++)

if (!final[w]) // if w belongs to V-S

if (D[w] < min) {

v = w;

min = D[w];

}

final[v] = true; // add v to S

// modify D and P

for (w = 0; w < G .vexnum; w++)

if (!final[w] && (min + G .arcs[v][w] < D[w])) {

D[w] = min + G .arcs[v][w];

P[w] = P[v];

P[w][w] = true;

}

}

}

算法分析：总的时间复杂度是2()O n

2. 每对顶点之间的最短路径问题

解决方法A ：每次以一个顶点为源点，重复执行Dijkstra 算法n 次，总的执行时间为3()O n 解决方法B ：Floyd 算法

基本思想：假设求从顶点i v 到j v 的最短路径。如果从i v 到j v 有弧，则从i v 到j v 存在一条长度为arcs[i][j]的路径，该路径不一定是最短路径，需要进行n 次试探。首先考虑路径0(,,)i j v v v 是否存在（即判别弧0(,)i v v 和0(,)j v v 是否存在）。如果存在，则比较(,)i j v v 和0(,,)i j v v v 的路径长度，取长度较短者为从i v 到j v 的中间顶点的序号不大于0的最短路径。在一般情况下，若(,...,)i k v v 和(,...,)k j v v 分别是从i v 到k v 和从k v 到j v 的中间顶点的序号不大于k-1的最短路径，则将(,...,,...,)i k j v v v 和已经得到的从i v 到j v 且中间顶点序号不大于k-1的最短路径相比较，其长度较短者便是从i v 到j v 的中间顶点的序号不大于k 的最短路径。这样，在经过n 次比较后，最后求得的必是从i v 到j v 的最短路径。定义一个n 阶方阵序列(1)(0)(1)()(1),,,...,,...,k n D D D D D --，其中(1)[][].[][]D i j G arcs i j -=，()(1)(1)(1)[][]{[][],[][][][]},01k k k k D i j Min D i j D i k D k j k n ---=+≤≤-

Floyd 算法代码：

void shortestPath_Floyd(Graph G, PathMatrix& P[], DistanceMatrix& D) {

// the value of D[v][w] means the shortest path from v to w

// P[v][w][u] = true means the shortest path from v to w contains vertex u

for (v = 0; v < G.vexnum; v++)

for (w = 0; w < G .vexnum; w++) {

D[v][w] = G .arcs[v][w];

for (u = 0; u < G .vexnum; u++) P[v][w][u] = false;

if (D[v][w] < INFINITY) {

P[v][w][v] = true;

P[v][w][w] = true;

}

}

// modify P and D

for (u = 0; u < G.vexnum; u++)

for (v = 0; v < G .vexnum; v++)

for (w = 0; w < G .vexnum; w++)

if (D[v][u] + D[u][w] < D[v][w]) {

D[v][w] = D[v][u] + D[u][w];

for (i = 0; i < G .vexnum; i++) P[v][w][i] = P[v][u][i] || P[u][w][i]; }

}

算法分析：时间复杂度为3()O n