数据结构07：图

最新推荐文章于 2024-09-17 14:30:13 发布

黎可

最新推荐文章于 2024-09-17 14:30:13 发布

阅读量289

点赞数

分类专栏：数据结构文章标签：数据结构图

本文链接：https://blog.csdn.net/weixin_42834104/article/details/81670362

版权

数据结构专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1. 图的定义

图（Graph）是由定点的有穷非空集合和定点之间边的集合组成，通常表示为G(V, E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。

线性表中我们把数据元素叫元素，树中将数据元素叫结点，在图中数据元素，我们则称之为顶点（Vertex）。
线性表中可以没有数据元素，称为空表。树中可以没有结点，叫做空树。在图结构中，不允许没有顶点。
图中，任意两个顶点之间都有可能有关系，顶点之间的逻辑关系用边来表示。

1.1 各种图的定义

无向边：若顶点 $v_i$ 到 $v_j$ 之间的边没有方向，则称这条边为无向边（Edge），用无序偶对 $(v_i, v_j)$ 来表示。
如果图中任意两个顶点之间的边都是无向边，则称该图为无向图（Undirected graphs）。
这里写图片描述
如上图， $G_1 = (V_1, \lbrace{E_1}\rbrace)$ ，其中顶点集合 $V_1 = \lbrace{A, B, C, D}\rbrace$ ；边集合 $E_1=\lbrace{(A, B), (B, C), (C, D), (D, A), (A, C)}\rbrace$
有向边：若从顶点 $v_i$ 到 $v_j$ 的边有方向，则称这条边为有向边，也称为弧（Arc）。用有序偶<script type="math/tex" id="MathJax-Element-27"> </script>来表示， $v_i$ 称为 弧尾（Tail）， $v_j$ 称为 弧头（Head）。
如果图中任意两个顶点之间的边都是有向边，则称该图为 有向图（Directed graphs）。
这里写图片描述
如上图， $G_2 = (V_2, \lbrace{E_2}\rbrace)$ )，其中顶点集合 $V_2 = \lbrace{A, B, C, D}\rbrace$ ；弧集合 $E_2 = \lbrace{<A, D>, <B, A>, <C, A>, <B, C>}\rbrace$ 。
在图中，若不存在顶点到其自身的边，切同一条边不重复出现，则称这样的图为 简单图。
在无向图中，如果任意两个顶点之间都存在边，则称该图为 无向完全图。
这里写图片描述
在有向图中，如果任意两个顶点之间都存在方向互为相反的两条弧，则称该图为 有向完全图。

有很少条边或弧的图称为 稀疏图。反之称为 稠密图。
有些图的边或弧具有与它相关的数字，这种与图的边或弧相关的数叫做 权（Weight）。带权的图通常称为 网（Network）。
假设有两个图 $G = (V, \lbrace{E}\rbrace)$ 和 $G' = (V', \lbrace{E'}\rbrace)$ ，如果 $V' \subseteq V$ 且 $E' \subseteq E$ ，则称G’为G的 子图（Subgraph）。
这里写图片描述

1.2 图的顶点与边间关系

对于无向图 $G = (V, \lbrace{E}\rbrace)$ ，如果边 $(v, v') \in E$ ，则称顶点v和v’互为邻接点（Adjacent），即v和v’相邻接。边(v, v’)依附（incident）于顶点v和v’，或者说 $(v, v')$ 与顶点v和v’相关联。顶点v的度（Degree）是和v相关联的边的数目，记为TD(v)。
对于有向图 $G = (V, \{E\})$ ，如果弧 <v,v′>∈E <script type="math/tex" id="MathJax-Element-41"> \in E</script>，则称顶点v邻接到顶点v’，顶点v’邻接自顶点v。弧 <v,v′> <script type="math/tex" id="MathJax-Element-42"> </script>和顶点v，v’相关联。以顶点v为头的弧的数目称为v的 入度（InDegree），记为ID(v)；以v为尾的弧的数目称为v的 出度（OutDegree），记为OD(v)；
无向图 $G = (V, \{E\})$ 中从顶点v到顶点v’的 路径（Path）是一个顶点序列（ $v=v_{i，0}, v_{i,1},..., v_{i,m}=v'$ ），其中 $(v_{i, j-1}) \in E, 1<= j <= m。$
这里写图片描述
如果G是有向图，则路径也是有向的，顶点序列应满足 <vi,j−1,vi,j>∈E,1<=j<=m <script type="math/tex" id="MathJax-Element-46"> \in E, 1 <= j <= m</script>。
路径的长度是路径上的边或弧的数目。
第一个顶点到最后一个顶点相同的路径称为 回路或环（Cycle）。序列中顶点不重复出现的路径称为 简单路径。除了第一个顶点和最后一个顶点之外，其余顶点不重复出现的回路，称为 简单回路或简单环。

1.2 连通图相关术语

在无向图G中，如果从顶点v到顶点v’有路径，则称v和v’是连通的。如果对于图中任意两个顶点 $v_i、v_j \in E，v_i$ 和 $v_j$ 都是连通的，则称G是连通图（Connected Graph）。
无向图中的极大连通子图称为连通分量。注意连通分量的概念，它强调：
- 要是子图
- 子图要是连通的
- 连通子图含有极大顶点数
- 具有极大顶点数的连通子图包含依附于这些顶点的所有边
在有向图G中，如果对于每一对 $v_i、v_j \in V、v_i != v_j$ ，从 $v_i$ 到 $v_j$ 和从 $v_j$ 到 $v_i$ 都存在路径，则称G是强连通图。有向图中的极大强两桶子图称作有向图的强连通分量。

1.3 图的定义与术语总结

图按照有无方向分为无向图和有向图。无向图由顶点和边构成，有向图由顶点和弧构成。弧有弧尾和弧头之分。
图按照边或弧的多少分稀疏图和稠密图。如果任意两个顶点之间都存在边叫完全图，有向的叫有向完全图。若无重复的边或顶点到自身的边则叫简单图。
图中顶点之间有邻接点、依附的概念。无向图顶点的变数叫做度，有向图顶点分为入度和出度。
图上的边或弧上带权则称为网。
图中顶点间存在路径，两顶点存在路径则说明是连通的，如果路径最终回到起始点则称为环，当中不重复叫简单路径。若任意两顶点都是连通的，则图就是连通图，有向则称强连通图。图中有子图，若子图极大连通则就是连通分量，有向的则称强连通分量。
无向图中连通且n个顶点n - 1条边叫生成树。有向图中一顶点入度为0其余顶点入度为1的叫有向树。一个有向图由若干棵有向树构成生成森林。

2. 图的抽象数据类型

ADT 图（Graph）
Data
    顶点的有穷非空集合和边的集合。
Operation
    CreateGraph(*G, V, VR)：按照顶点集V和边弧集VR的定义构造图G
    DestroyGraph(*G)：图G存在则销毁
    LocateVex(G, u)：若图G中存在顶点u，则返回图中的位置
    GetVex(G, v)：返回图G中顶点v的值
    PutVex(G, v, value)：将图G中顶点v赋值value
    FirstAdjVex(G, *v)：返回顶点v的一个邻接顶点，若顶点在G中无邻接顶点返回空。
    NextAdjVex(G, v, *w)：返回顶点v相对于顶点w的下一个邻接顶点，若w是v的最后一个邻接点则返回空
    InsertVex(*G, v)：在图G中增添新顶点v
    DeleteVex(*G, v)：删除图G中顶点v及其相关的弧
    InsertArc(*G, v, w)：在图G中增添弧<v, w>，若G是无向图，还需要增添对称呼<w, v>
    DeleteArc(*G, v, w)：在图G中删除弧<v, w>，若G是无向图，则还删除对称弧<w, v>
    DFSTraverse(G)：对图G中进行深度优先遍历，在遍历过程对每个顶点调用
    HFSTraverse(G)：对图G中进行广度优先遍历，在遍历过程对每个顶点调用
endADT

3. 图的存储结构

3.1 邻接矩阵

图的邻接矩阵（Adjacency Matrix）存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组（称为邻接矩阵）存储图中的边或弧的信息。
这里写图片描述
带权图

那么邻接矩阵是如何实现图的创建的饿呢？我们先来看看图的邻接矩阵存储的结构，代码如下：

typedef char VertexType;    /* 顶点类型应由用户定义 */
typedef int EdgeType;   /* 边上的权值类型应由用户定义 */
#define MAXVEX 100  /* 最大顶点数，应由用户定义 */
#define INFINITY 65535  /* 用65535代表正无穷 */
typedef struct {
    VertexType vexs[MAXVEX];
    EdgeType arc[MAXVEX][MAXVEX];
    int numVertexes, numEdges;
}MGraph;

有了这个结构定义，我们构造一个图，其实就是给顶点表和边表输入数据的过程。

/* 建立无向网图的邻接矩阵表示 */
void CreateMGraph(MGraph *G) {
    int i, j, k, w;
    printf("输入顶点数和边数：\n");
    scanf("%d, %d", &G->numVertexes, &G->numEdges);
    for(i = 0; i < G->numVertexes; i++)
        scanf(&G->vexs[i]);
    for(i = 0; i < G->numVertexes; i++)
        for(j = 0; j < G->numVertexes; j++)
            G->arc[i][j] = INFINITY;
    for(k = 0; k < G->numEdges; k++) {
        printf("输入边(vi, vj)上的下标i，下标j和权w:\n");
        scanf("%d, %d, %d", &i, &j, &w);
        G->arc[i][j] = w;
        G->arc[j][i] = G->arc[i][j];
    }
}

3.2 邻接表

数组与链表相结合的存储方法称为邻接表（Adjacency List）。
邻接表的处理办法：
1. 图中顶点用一个一维数组存储
2. 图中每个顶点 $v_i$ 的所有邻接点构成一个线性表，由于邻接点的个数不定，所以用单链表存储
这里写图片描述

对于带权值的网图，可以在边表结点定义中再增加一个weight的数据域，存储权值信息即可。

结点定义代码：

typedef char VertexType;    /* 顶点类型应由用户定义 */
typedef int EdgeType;   /* 边上的权值类型应由用户定义 */

typedef struct EdgeNode {   /* 边表结点 */
    int adjvex; /* 邻接点域，存储该顶点对应的下标 */
    EdgeType weight; /* 用于存储权值，对于非网图可以不需要 */
    struct EdgeNode *next; /* 链域，指向下一个邻接点 */
}EdgeNode;

typedef struct VertexNode { /* 顶点表结点 */
    VertexType data; /* 顶点域，存储顶点信息 */
    EdgeNode *fristedge; /* 边表头指针 */
}VertexNode, AdjList[MAXVEX];

typedef struct {
    AdjList adjList;
    int numVertexes, numEdges; /* 图中当前顶点数和边数 */
}GraphAdjList;

无向图的邻接表创建代码如下：

/* 建立图的邻接表结构 */
void CreateALGraph(GraphAdjList *G) {
    int i, j, k;
    EdgeNode *e;
    printf("输入顶点数和边数：\n");
    scanf("%d, %d", &G->numVertexes, &G->numEdges); /* 输入顶点数和边数 */
    for(i = 0; i < G->numVertexes; i++) { /* 读入顶点信息，建立顶点表 */
        scanf(&G->adjList[i].data); /* 输入顶点信息 */
        G->adjList[i].firstedge = NULL; /* 将边表置为空表 */
    }
    for(k = 0; k < G->numEdges; k++) { /* 建立边表 */
        printf("输入边(vi, vj)上的顶点序号:\n");
        scanf("%d, %d", &i, &j); /* 输入边(vi, vj)上的顶点序号 */
        e = (EdgeNode *)malloc(sizeof(EdgeNode)); 
        e->adjvex = j; /* 邻接序号为j */
        e->next = G->adjList[i].firstedge; /* 将e指针指向当前顶点指向的结点 */
        G->adjList[i].firstedge = e; /* 将当前顶点的指针指向e */
        e = (EdgeNode *)malloc(sizeof(EdgeNode));
        e->adjvex = i; /* 邻接序号为i */
        e->next = G->adjList[j].firstedge; /* 将e指针指向当前顶点指向的结点 */
        G->adjList[j].firstedge = e; /* 将当前顶点的指针指向e */
    }
}

3.3 十字链表

把邻接表与逆邻接表结合起来，就是十字链表（Orthogonal List）。
这里写图片描述

3.4 邻接多重表

这里写图片描述
其中ivex和jvex是与某条边依附的两个顶点在顶点表中小标。ilink指向依附顶点ivex的下一条边，jlink指向依附顶点jvex的下一条边。这就是邻接多重表结构。

3.5 边集数组

边集数组是由两个一维数组构成。一个是存储顶点的信息；另一个是存储边的信息，这个边数组每个数据元素由一条边的起点下标（begin）、终点下标（end）和权（weight）组成。
这里写图片描述

4. 图的遍历

从图中某一顶点触发访遍图中其余顶点，且使每一个顶点仅被访问一次，这一过程就叫做图的遍历（Traversing Graph）。

4.1 深度优先遍历

深度优先遍历（Depth_First_Search），有时称为深度优先搜索，简称为DFS。

typedef int Boolean;
bBoolean visited[MAX];
/* 邻接矩阵的深度优先递归算法 */
void DFS(MGraph G, int i) {
    int j;
    visited[i] = TRUE;
    printf("%c", G.vexs[i]); /* 打印顶点 */
    for(j = 0; j < G.numVertexes; j++)
        if(G.arc[i][j] == 1 && !visited[j])
            DFS(G, j);
}

/* 邻接矩阵的深度遍历操作 */
void DFSTraverse(MGraph G) {
    int i;
    for(i = 0; i< G.numVertexes; i++)
        visited][i] = FALSE;
    for(i = 0; i < G.numVertexes; i++)
        DFS(G, i);
}

/* 邻接表的深度优先递归算法 */
void DFS(GraphAdjList GL, int i) {
    EdgeNode *p;
    visited[i] = TRUE;
    printf("%c", GL->adjList[i].data);
    p = GL->adjList[i].firstedge;
    while(p) {
        if(!visited[p->adjvex])
            DFS(GL, p->adjvex);
        p = p->next;
    }
}

/* 邻接表的深度遍历操作 */
void DFSTraverse(GraphAdjList GL) {
    int i;
    for(i = 0; i < GL->numVertexes; i++)
        visited[i] = FALSE;
    for(i = 0; i < GL->numVertexes; i++)
        if(!visited[i]
            DFS(GL, i);
}

4.2 广度优先遍历

广度优先遍历（Breadth_First_Search），又称为广度优先搜索，简称BFS。

/* 邻接矩阵的广度遍历算法 */
void BFSTraverse(MGraph G) {
    int i, j;
    Queue Q;
    for(i = 0; i < G.numVertexes; i++)
        visited[i] = FALSE;
    InitQueue(&Q);
    for(i = 0; i < G.numVertexes; i++) {
        if(!visited[i]) {
            visited[i] = TRUE;
            printf("%c", G.vexs[i]);
            EnQueue(&Q, i);
            while(!QueueEmpty(Q)) {
                DeQueue(&q, &i);
                for(j = 0; j < G.numVertexes; j++) {
                    if(G.arc[i][j] == 1 && !visited[j]) {
                        visited[j] = TRUE;
                        printf("%c", G.vexs[j]);
                        EnQueue(&Q, j);
                    }
                }
            }
        }
    }
}

/* 邻接表的广度遍历算法 */
void BFSTraverse(GraphAdjList GL) {
    int i;
    EdgeNode *p;
    Queue Q;
    for(i = 0; i < GL->numVertexes; i++)
        visited[i] = FALSE;
    InitQueue(&Q);
    for(i = 0; i < GL->numVertexes; i++) {
        if(!visited[i]) {
            visited[i] = TRUE;
            printf("%c", GL->adjList[i].data);
            EnQueue(&Q, i);
            while(!QueueEmpty(Q)) {
                DeQueue(&Q, &i);
                p = GL->adjList[i].firstedge;
                while(p) {
                    if(!visited[p->adjvex]) {
                        visited[p->adjvex] = TRUE;
                        printf("%c", GL->adjList[p->adjvex].data);
                        EnQueue(&Q, p->adjvex);
                    }
                    p = p->next;
                }
            }
        }
    }
}

5. 最小生成树

我们把构造连通网的最小代价生成树称为最小生成树（Minimum Cost Spanning Tree）。

5.1 普里姆（Prim）算法

这里写图片描述

/* Prim算法生成最小生成树 */
void MiniSpanTree_Prim(MGraph G) {
    int min, i, j, k;
    int adjvex[MAXVEX]; /* 保存相关顶点下标 */
    int lowcost[MAXVEX]; /* 保存相关顶点间边的权值 */
    lowcost[0] = 0;
    adjvex[0] = 0;
    for(i = 1; i < G.numVertexes; i++) {
        lowcost[i] = G.arc[0][i];
        adjvex[i] = 0;
    }
    for(i = 1; i < G.numVertexes; i++) {
        min = INFINITY;
        j = 1; k = 0;
        while(j < G.numVertexes) {
            if(lowcost[j] != 0 && lowcost[j] < min) {
                min = lowcost[j];
                k = j;
            }
            j++;
        }
    }
    printf("(%d, %d)", adjvex[k], k);
    lowcost[k] = 0; /* 将当前顶点的权值设置为0，表示此顶点已经完成任务 */
    for(j = 1; j < G.numVertexes; j++) {
        if(lowcost[j] != 0 && G.arc[k][j] < lowcost[j]) {
            lowcost[j] = G.arc[k][j];
            adjvex[j] = k;
        }
    }
}

5.2 克鲁斯卡尔（Kruskal）算法

/* Kruskal算法生成最小生成树 */
void MiniSpanTree_Kruskal(MGraph G) {
    int i, n,, m;
    Edge edges[MAXEDTGE]; /* 定义边集数组 */
    int parent[MAXVUEX]; /* 定义一数组用来判断边与边是否形成环路 */
    for(i = 0; i < G.numVertexes; i++)
        parent[i] = 0;
    for(i = 0; i< G.numEdges; i++) {
        n = Find(parent, edges[i].begin);
        m = Find(parent, edges[i].end);
        if(n != m) {
            parent[n] = m; /* 将此边的结尾顶点放入下标为起点的parent中 */
            printf("(%d, %d) %d", edges[i].begin, edges[i].end, edges[i].weight);
        }
    }
}

/* 查找连线顶点的尾部下标 */
int Find(int *parent, int f) {
    while(parent[f] > 0)
        f = parent[f];
    return f;
}

6. 最短路径

最短路径，是指两顶点之间经过的边上权值只和最少的路径，并且我们称路径上的第一个顶点是源点，最后一个顶点是终点。

6.1 迪杰斯特拉（Dijkstra）算法

#define MAXVEX 9
#define INFINITY 65535
typedef int Pathmatrix[MAXVEX]; /* 用于存储最短路径下标的数组 */
typedef int ShortPathTable[MAXVEX]; /* 用于存储到各点最短路径的权值和 */
/* Dijkstra算法，求有向网G的v0顶点到其余顶点v最短按路径P[v]及带权长度D[v] P[v]的值为前驱顶点下标，D[v]表示v0到v的最短路径长度和*/
void ShortestPath_Dijkstra(MGraph G, int v0, Pathmatrix *P, ShortPathTable *D) {
    int v, w, k, min;
    int final[MAXVEX];
    for(v = 0; v < G.numVertexes; v++) {
        final[v] = 0;
        (*D)[v] = G.matrix[v0][v];
        (*P)[v] = 0;
    }
    (*D)[v0] = 0;
    final[v0] = 1;
    for(v = 1; v < G.numVertexes; v++) {
        min = INFINITY;
        for(w = 0; w < G.numVertexes; w++) {
            if(!final[w] && (*D)[w] < min) {
                k = w;
                min = (*D)[w];
            }
        }
        final[k] = 1;
        for(w = 0; w < G.numVertexes; w++) {
            if(!final[w] && (min + G.matrix[k][w] < (*D)[w]) {
                (*D)[w] = min + G.matrixp[k][w];
                (*P)[w] = k;
            }
        }
    }
}

6.2 弗洛伊德（Floyd）算法

typedef int Pathmatrix[MAXVEX][MAXVEX];
typedef int ShortPathTable[MAXVEX][MAXVEX];

/* Floyd算法，求网图G中各顶点v到其余顶点w最短路径P[v][w]即带权长度D[v][w] */
void ShortestPath_Floyd(MGraph G, Pathmatrix *P, ShortPathTable *D) {
    int v, w, k;
    for(v = 0; v < G.numVertexes; ++v) { /* 初始化D与P */
        for(w = 0; w < G.numVertexes; ++w) {
            (*D)[v][w] = G.matrix[v][w]; /* D[v][w]值即为对应点间的权值 */
            (*P)[v][w] = w;
        }
    }
    for(k = 0; k < G.numVertexes; ++k) {
        for(v = 0; v < G.numVertexes; ++v) {
            for(w = 0; w < G.numVertexes; ++w) {
                if((*D)[v][w] > (*D)[v][k] + (*D)[k][w]) {
                    /* 如果经过下标为k顶点路径比原两点间路径更短 */
                    /* 将当前两点间权值设为更小的一个 */
                    (*D)[v][w] = (*D)[v][k] + (*D)[k][w];
                    (*P)[v][w] = (*P)[v][k];
                }
            }
        }
    }
}

7. 拓扑排序

7.1 拓扑排序介绍

在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的有限关系，这样的有向图为顶点表示活动的网，我们称为AOV网（Activity On Vertex Network）。
设G=(V, E)是一个具有n个顶点的有向图，V中的顶点序列 $V_1, V_2, ......, V_n$ 满足若从顶点 $v_i$ 到 $v_j$ 有一条路径，则在顶点序列中顶点 $v_i$ 必在顶点 $v_j$ 之前。则我们称这样的顶点序列为一个拓扑序列。
拓扑排序，就是对一个有向图构造拓扑序列的过程。

7.2 拓扑排序算法

基本思路：从AOV网中选择一个入度为0的顶点输出，然后删去此顶点，并删除以此顶点为尾的弧，继续重复此步骤，直到输出全部顶点，或者AOV网中不存在入度为0的顶点为止。
这里写图片描述

typedef struct EdgeNode { /* 边表结点 */
    int adjvex; /* 邻接点域，存储该顶点对应的下标 */
    int weight; /* 用于存储权值，对于非网图可以不需要 */
    struct EdgeNode *next; /* 链域，指向下一个邻接点 */
}EdgeNode;

typedef struct VertexNode { /* 顶点表结点 */
    int in; /* 顶点入度 */
    int data; /* 顶点域，存储顶点信息 */
    EdgeNode *firstedge; /* 边表头指针 */
}VertexNode, AdjList[MAXVEX];

typedef struct {
    AdjList adjList;
    int numVertexes, numEdges; /* 图中当前顶点数和边数 */
}graphAdjList, *GraphAdjList;

Status TopologicalSort(GraphAdjList GL) {
    EdgeNode *e;
    int i, k, gettop;
    int top = 0; /* 用于栈指针下标 */
    int count = 0; /* 用于统计输出顶点的个数 */
    int *stack; /* 建栈存储入度为0的顶点 */
    stack = (int *)malloc(GL->numVertexes * sizeof(int));
    for(i = 0; i < GL->numVertexes; i++)
        if(GL->adjList[i].in == 0)
            stack[++top] = i; /* 将入度为0的顶点入栈 */
    while(top != 0) {
        gettop = stack[top--]; /* 出栈 */
        printf("%d -> ", GL->adjList[gettop].data); /* 打印此结点 */
        count++; /* 统计输出顶点数 */
        for(e = GL->adjList[gettop].firstedge; e; e = e->next) { /* 遍历顶点弧表 */
            k = e->adjvex;
            if(!(--GL->adjList[k].in)) /* 将k号顶点邻接点的入度减1 */
                stack[++top] = k; /* 若为0则入栈，以便于下次循环输出 */
        }
    }
    if(count < GL->numVertexes) /* 如果count小于顶点数，说明存在环 */
        return ERROR;
    else
        return OK;
}

8. 关键路径

在一个表示工程的带权有向图中，用顶点表示事件，用有向边表示活动，用边上的权值表示活动的持续时间，这种有向图表示活动的网，我们称之为AOE网（Activity On Edge Network）。
这里写图片描述
路径上各个活动所持续的时间之和称为路径长度，从源点到汇点具有最大长度的路径叫关键路径，在关键路径上的活动叫关键活动。

8.1 关键路径算法原理

事件的最早发生时间etv（earliest time of vertex）：即顶点 $V_k$ 的最早发生时间
事件的最晚发生时间ltv（latest time of vertex）：即顶点 $V_k$ 的最晚发生时间，也就是每个顶点对应的事件最晚需要开始的时间，超出此时间将会延误整个工期
活动的最早开工时间ete（earliest time of edge）：即弧 $a_k$ 的最早发生时间
活动的最晚开工时间lte（lastest time of edge）：即弧 $a_k$ 的最晚发生时间，也就是不退出工期的最晚开工时间

8.2 关键路径算法

这里写图片描述

int *etv, *ltv; /* 事件最早发生时间和最迟发生时间数组 */
int *stack2; /* 用于存储拓扑序列的栈 */
int top2; /* 用于stack2的指针 */

/* 拓扑排序，用于关键路径计算 */
Status TopologicalSort(GraphAdjList GL) {
    EdgeNode *e;
    int i, k, gettop;
    int top = 0; /* 用于栈指针下标 */
    int count = 0; /* 用于统计输出顶点的个数 */
    int *stack; /* 建栈将入度为0的顶点入栈 */
    stack = (int *)malloc(GL->numVertexes * sizeof(int));
    for(i = 0; i < GL->numVertexes; i++)
        if(0 == GL->adjList[i].in)
            stack[++top] = i;
    top2 = 0;
    etv = (int *)malloc(GL->numVertexes * sizeof(int)); /* 事件最早发生时间 */
    for(i = 0; i< GL->numVertexes; i++)
        etv[i] = 0; /* 初始化为0 */
    stack2 = (int *)malloc(GL->numVertexes * sizeof(int));
    while(top != 0) {
        gettop = stack[top--];
        count++;
        stack2[++top2] = gettop; /* 将弹出的顶点序号压入拓扑序列的栈 */
        for(e = GL->adjList[gettop].firstedge; e; e = e->next) {
            k = e->adjvex;
            if(!(--GL->adjList[k].in))
                stack[++top] = k;
            if((etv[gettop] + e->weight) > etv[k]) /* 求各顶点事件最早发生时间值  */
                etv[k] = etv[gettop] + e->weight;
        }
    }
    if(count < GL->numVertexes)
        return ERROR;
    else
        return OK;
}

/* 求关键路径，GL为有向网，输出GL的各项关键活动 */
void CriticalPath(GraphAdjList GL) {
    EdgeNode *e;
    int i, gettop, k, j;
    let ete, lte;
    TopologicalSort(GL);
    ltv = (int *)malloc(GL->numVertexes * sizeof(int));
    for(i = 0; i < GL->numVertexes; i++)
        ltv[i] = etv[GL->numVertexes - 1];
    while(top2 != 0) {
        gettop = stack2[top2--];
        for(e = GL->adjList[gettop].firstedge; e; e = e->next) {
            k = e->adjvex;
            if(ltv[k] - e->weight < ltv[gettop])
                ltv[gettop] = ltv[k] - e->weight;
        }
    }
    for(j = 0; j < GL->numVertexes; j++) {
        for(e = GL->adjList[j].firstedge; e; e=e->next) {
            k = e->adjvex;
            ete = etv[j];
            lte = ltv[k] - e->weight;
            if(ete == lte)
                printf("<v%d, v%d> length : $d", GL->adjList[j].data, GL->adjList[k].data, e->weight);
        }
    }
}