数据结构与算法--图的应用拓扑排序 & 关键路径

亮亮不想说话95888
314 阅读10分钟

1. 拓扑排序

  • 拓扑排序简介

    假设在如下面的一张 有向图 中，顶点表示活动，弧表示活动之间的优先关系，这样的 有向图 顶点表示活动网，我们称之为 AOV 网。

  上面 AOV 网的路径为：V1 -> V2 -> V3 -> V4 -> V5 或者 V1 -> V2 -> V3 -> V4 -> V5

设 G = （V，E）是一个具有 n个 顶点的 有向图，V 中的顶点V1、V2...Vn，若满足从顶点 Vi 到 Vj 有一条路径，则在顶点序列Vi必须在Vj之前，则我们称这样的顶点序列为 拓扑排序。

所谓 拓扑排序，其实是对一个有向图构造拓扑序列的过程。

构造过程拓扑序列会产生两个结果:

1. 如果此网中的全部顶点被输出，说明是不存在环（回路）的AOV 网
2. 如果输出顶点小于总顶点数，说明是存在环（回路）的，不是AOV 网

  • 拓扑排序实现

    如上的一个AOV 网图， 那么AOV 网图怎么存储比较合适呢？

    我们可以设计一个 邻接表来存储，邻接表节点中增加一个变量，用来存储顶点的入度，邻接表节点结构如下：

顶点表结点

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

图结构:

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

思路分析：

1. 利用栈的特性，先将图网中所有入度为 0 的顶点下标入栈，
2. 循环遍历栈，直到栈为空
3. 栈顶元素出栈，并遍历与栈顶相连接的弧
   3.1 获取与栈顶元素对应顶点连接的顶点
   3.2 将与栈顶元素对应顶点连接的顶点入度减一
   3.3 判断入度是否为 0 ，为 0 则入栈

先定义图、邻接矩阵和邻接表

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXEDGE 20
#define MAXVEX 14
#define INFINITYC 65535

/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Status;

// 邻接矩阵
typedef struct {
    int vexs[MAXVEX];
    int arc[MAXVEX][MAXVEX];
    int numVertexes, numEdges;
}MGraph;
// 邻接表结构
// 边表节点
typedef struct EdgeNode{
    int adjvex; // 邻接顶点域，存储顶点的下标
    int weight; // 权值
    struct EdgeNode *next; // 链域，存储下一个邻接点
}EdgeNode;

// 顶点表
typedef struct VertexNode{
    int inCount;  // 入度数
    int data;     // 顶点信息
    EdgeNode *firstEdge;  // 边表头指针
}VertexNode, AdjList[MAXVEX];


// 图结构
typedef struct {
    AdjList adjList;
    int numVertexes, numEdges;
}graphAdiList, *GraphAdjList;

由于一个一个的输入图的顶点和边，比较麻烦，我们定义一个函数，来构建邻接矩阵的图，然后转换为邻接表

// 1.构成AOV网图
void CreateMGraph(MGraph *G)/* 构件图 */
{
    int i, j;
    G->numVertexes = MAXVEX;
    G->numEdges    = MAXEDGE;
    
    for (i = 0; i < G->numVertexes; i++){
        G->vexs[i] = i;
    }
    
    // 初始化图
    for (i = 0; i < G->numVertexes; i++){
        for (j = 0; j < G->numVertexes; j++){
            G->arc[i][j] = 0;
        }
    }
    
    G->arc[0][4] =1;
    G->arc[0][5] =1;
    G->arc[0][11]=1;
    G->arc[1][2] =1;
    G->arc[1][4] =1;
    G->arc[1][8] =1;
    G->arc[2][5] =1;
    G->arc[2][6] =1;
    G->arc[2][9] =1;
    G->arc[3][2] =1;
    G->arc[3][13]=1;
    G->arc[4][7] =1;
    G->arc[5][8] =1;
    G->arc[5][12]=1;
    G->arc[6][5] =1;
    G->arc[8][7] =1;
    G->arc[9][10]=1;
    G->arc[9][11]=1;
    G->arc[10][13]=1;
    G->arc[12][9] =1;
}

// 2.将AOV网图借助邻近矩阵转换成邻接表结构
void CreateALGraph(MGraph G,GraphAdjList *GL)
{
    int i,j;
    EdgeNode *e;
    
    // 创建图
    (*GL) = (GraphAdjList)malloc(sizeof(graphAdiList));
    // 对边和顶点赋值
    (*GL)->numEdges = G.numEdges;
    (*GL)->numVertexes = G.numVertexes;
 
    
    // 读入顶点表
    for (i = 0; i < G.numVertexes; i++) {
        (*GL)->adjList[i].inCount = 0;
        (*GL)->adjList[i].data    = G.vexs[i];
        (*GL)->adjList[i].firstEdge = NULL;
    }
    
    for (i = 0; i < G.numVertexes; i++) {
        for (j = 0; j < G.numVertexes; j++) {
            if (G.arc[i][j]) {
                // 创建边表节点
                e = (EdgeNode *)malloc(sizeof(EdgeNode));
                //邻接序号为j
                e->adjvex = j;
                // 将当前顶点上的指向的结点指针赋值给e
                e->next = (*GL)->adjList[i].firstEdge;
                // 将当前顶点的指针指向e
                (*GL)->adjList[i].firstEdge = e;
                // 入度加1
                (*GL)->adjList[j].inCount++;
            }
        }
    }
    
}

接下来就是关键的拓扑排序

// 若AOV网图无回路则输出拓扑排序的序列并且返回状态值1,若存在回路则返回状态值0// 拓扑排序:解决的是一个工程能否顺序进行的问题
Status TopologicalSort(GraphAdjList GL){
    EdgeNode *e;
    int i, k, getTop;
    int top  = 0;  // 栈顶下标
    int count = 0;// 统计顶点个数
    
    // ✅ 创建栈
    int *stack = (int *)malloc(sizeof(int) * GL->numVertexes);
    
    // ✅ 遍历入度为0的顶点入栈
    for (i = 0; i < GL->numVertexes; i++) {
        if (GL->adjList[i].inCount == 0) {
            stack[++top] = i;
        }
    }
    printf("top = %d\n",top);
    
    // ✅ 循环遍历栈
    while (top != 0) {
        // ✅ 出栈栈顶元素
        getTop = stack[top--];
        printf("%d -> ",GL->adjList[getTop].data);
        //输出顶点，并计数
        count++;
        // ✅ 遍历与栈顶相连接的弧
        for (e = GL->adjList[getTop].firstEdge; e; e = e->next) {
            // ✅ 获取与gettop连接的顶点
            k = e->adjvex;
            // ✅ 将与gettop连接的顶点入度减1.判断如果当前减1后为0,则入栈
            if (!(--GL->adjList[k].inCount)) {
                //将k入栈到stack中,并且top加1;
                stack[++top]=k;
            }
        }
    }
    
    // ✅ 判断是否把所有的顶点都输出. 则表示找到了拓扑排序;
    if(count < GL->numVertexes)
        return ERROR;
    else
        return OK;
}

2. 关键路径

在一个表示工程的带权有向图中，用顶点表示事件，用有向边表示活动，边的权重表示活动的持续事件，这种有向图的边表表示活动的网，称之为AOE网。

没有入边的顶点称之为始点或源点； 没有出边的顶点称之为终点或汇点，由于一个工程，总有一个开始一个结束，所以正常情况下，AOE网只有一个源点和汇点。

比图下面的AOE网

在AOE网中：

  • 路径上各个活动所持续的时间之和，称为路径长度
  • 从源点到汇点具有最大的路径叫关键路径
  • 在关键路径上的活动叫关键活动

那么怎么求解一个 AOE网 的关键路径呢？接下来看一下，关键路径求解过程中的几个核心参数。

  • 事件最早发生的时间 etv：即顶点Vk的最早发生时间
  • 事件最晚发生的时间 ltv：即顶点Vk的最晚发生时间，也就是每个顶点对应的事件最晚需要开始的时间，超出此时间将会延误整个工期
  • 活动的最早开工时间**ete**：即弧Ak的最早发生时间
  • 活动的最晚开工时间**lte**：即弧Ak的最晚发生时间（不推迟工期的最晚开工时间）

求事件的最早发生时间 etv的过程，就是从头到尾去找拓扑序列的过程，所以在求解关键路径之前，我们需要调用一次拓扑排序的序列去计算etv和拓扑序列列表

对上面的AOE网图的 etv的求解分析 如下：

1. 从源点 V0->V1，a0 = 3，V0->V2，a1 = 4，所以etv[1] = 3，etv[2] = 4
2. V1->V3，a2 = 5，V2->V3，a4 = 8，所以etv[3] = max{3+5，4+8} = 12

由此可以推演出etv的计算公式：

对上面的AOE网图的 ltv的求解分析 如下：

首先将 ltv 初始化成 etv 最后一个事件的时间。(上图最终求得etv[9] = 27)
1. 最后一个事件V9，没有弧表（因为是汇点），没有要更新的相关 ltv
2. V8->V9 长度为3，所以 ltv = min(27， 27-3) = 24，ltv[8] = 24
3. V7->V8 长度为5，所以 ltv = min(24， 24-5) = 19，ltv[7] = 19

依次类推最终可以推演出ltv的计算公式

代码实现：

// 定义邻接矩阵、邻接表、图
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXEDGE 30
#define MAXVEX 30
#define INFINITYC 65535

typedef int Status;    /* Status是函数的类型,其值是函数结果状态代码，如OK等 */

// 邻接矩阵
typedef struct {
    int vexs[MAXVEX];
    int arc[MAXVEX][MAXVEX];
    int numVertexes, numEdges;
}MGraph;
// 邻接表
typedef struct EdgeNode{
    int adjvex; // 邻接点域，存储顶点下标
    int weight; // 权重
    struct EdgeNode *next; // 链域，下一个邻接点
    
}EdgeNode;

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


// 图
typedef struct {
    AdjverList adjList;  // 顶点表
    int numVertexes, numEdges;
}graphAdjList, *GraphAdjList;


// ✅ 通过邻接矩阵将AOE网图转换为邻接表
void CreateMGraph(MGraph *G)/* 构件图 */
{
    int i, j;
    // 顶点数和边数
    G->numEdges = 13;
    G->numVertexes = 10;
    
    // 初始化图
    for(i = 0; i < G->numVertexes; i++){
        G->vexs[i] = i;
    }
    
    for(i = 0; i < G->numVertexes; i++){
        for(j = 0; j < G->numVertexes; j++){
            if(i == j){
                G->arc[i][j] = 0;
            }else {
                G->arc[i][j]=INFINITYC;
            }
        }
    }
    
    G->arc[0][1]=3;
    G->arc[0][2]=4;
    G->arc[1][3]=5;
    G->arc[1][4]=6;
    G->arc[2][3]=8;
    G->arc[2][5]=7;
    G->arc[3][4]=3;
    G->arc[4][6]=9;
    G->arc[4][7]=4;
    G->arc[5][7]=6;
    G->arc[6][9]=2;
    G->arc[7][8]=5;
    G->arc[8][9]=3;

}

void CreateALGraph(MGraph G,GraphAdjList *GL){
    int i, j;
    EdgeNode *e;
    
    *GL = (GraphAdjList)malloc(sizeof(graphAdjList));
    (*GL)->numVertexes = G.numVertexes;
    (*GL)->numEdges = G.numEdges;
    
    // 读取顶点表
    for (i = 0; i < (*GL)->numVertexes; i++) {
        (*GL)->adjList[i].in = 0;
        (*GL)->adjList[i].data = G.vexs[i];
        (*GL)->adjList[i].firstEdge = NULL;
    }
    
    // 读取边表
    for (i = 0; i < (*GL)->numVertexes; i++) {
        for (j = 0; j < (*GL)->numVertexes; j++) {
            if (G.arc[i][j] != 0 && G.arc[i][j] < INFINITYC) {
                e = (EdgeNode *)malloc(sizeof(EdgeNode));
                e->adjvex = j;
                e->weight = G.arc[i][j];
                
                e->next = (*GL)->adjList[i].firstEdge;
                (*GL)->adjList[i].firstEdge = e;
                (*GL)->adjList[j].in++;
            }
        }
    }
}

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

// ✅ 拓扑排序
Status TopologicalSort(GraphAdjList GL){
    
    int i, k, getTop;
    EdgeNode *e;
    int top = 0;
    int count = 0;
    
    // 初始化栈
    int *stack = (int *)malloc(sizeof(int) * GL->numVertexes);
    // 入度为0的顶点入栈
    for (i = 0; i < GL->numVertexes; i++) {
        if (GL->adjList[i].in == 0) {
            stack[++top] = i;
        }
    }
    // 创建初始化拓扑序列栈
    top2 = 0;
    stack2 = (int *)malloc(sizeof(int) * GL->numVertexes);
    
    // 事件最早发生时间数组
    etv = (int *)malloc(sizeof(int) * GL->numVertexes);
    for (i = 0 ; i < GL->numVertexes; i++) {
        //初始化
        etv[i] = 0;
    }
    
    while (top != 0) {
        // 出栈
        getTop = stack[top--];
        // 打印出栈顶点
        printf("%d -> ", GL->adjList[getTop].data);
        // 计数+1
        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;
            }
            
            //求各顶点事件的最早发生的时间etv值
            if ((etv[getTop] + e->weight) > etv[k]) {
                etv[k] = etv[getTop] + e->weight;
            }
        }
    }
    
    
    if(count < GL->numVertexes)
        return ERROR;
    else
        return OK;
    return OK;

}

// ✅ 求关键路径, GL为有向网,则输出G的各项关键活动;
void CriticalPath(GraphAdjList GL){
    
    EdgeNode *e;
    int i, j, k, getTop;
    // 声明活动最早和最晚发生时间
    int ete, lte;
    
    //求得拓扑序列,计算etv数组以及stack2的值
    TopologicalSort(GL);
    
    printf("etv:\n");
    for(i = 0; i < GL->numVertexes; i++){
        printf("etv[%d] = %d \n",i,etv[i]);
    }
           
    printf("\n");
    
    //事件最晚发生时间数组
    ltv = (int *)malloc(sizeof(int) * GL->numVertexes);
    
    // 初始化ltv数组
    for (i = 0; i < GL->numVertexes; i++) {
        ltv[i] = etv[GL->numVertexes-1];
    }
    
    //计算ltv(事件最晚发生时间) 出栈求ltv
    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;
            }
        }
    }
    
    //打印ltv 数组
    printf("ltv:\n");
    for (i = 0 ; i < GL->numVertexes; i++) {
        printf("ltv[%d] = %d \n",i,ltv[i]);
    }
    
    // 求解ete,lte 并且判断lte与ete 是否相等.相等则是关键活动;
    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("<%d-%d> length:%d\n",GL->adjList[j].data, GL->adjList[k].data, e->weight);
            }
        }
    }
}
avatar
文章
阅读
粉丝