数据结构（拓扑排序和关键路径）

拓扑排序

拓扑序列：

　　设G=(V，E)是一个具备n个顶点的有向图，V中顶点序列V1，V2，......，Vn知足若从顶点Vi到Vj有一条路径，则在顶点序列中顶点Vi必须在顶点Vj以前。则称这样的顶点序列为一个拓扑序列

拓扑排序

　　对一个无环有向图（AOV网）构造拓扑序列的过程

方法

• 从AOV网中选择一个没有前驱的顶点（该顶点的入度为0）并输出它
• 从网中删去该顶点，而且删去从该点发出的所有有向边
• 重复上述两步，直到剩余网中再也不存在没有前驱的顶点为止

由于要删除点和边，因此用邻接表较为方便

 1 #define MAXVEX 10
 2 
 3 //边表结点声明
 4 typedef struct EdgeNode{
 5     int adjvex;
 6     struct EdgeNode *next;
 7 }EdgeNode;
 8 
 9 //顶点结点声明
10 typedef struct VertexNode{
11     int in;//顶点入度
12     int data;
13     EdgeNode *firstedge;
14 }VertexNode,AdjList[MAXVEX];
15 
16 typedef struct{
17     AdjList adjList;
18     int numVertexes,numEdges;
19 }graphAdjList,* GraphAdjList;
20 
21 //拓扑排序算法
22 //若GL无回路，则会输入拓扑排序序列并返回OK,不然返回ERROE
23 Status TopoLogicalSort(GraphAdjList GL){
24     EdgeNode *e;
25     int i,k,gettop;
26     int top=0;//用于栈指针下标索引
27     int count=0;//用于统计输出顶点的个数
28     int *stact;//用于存储入度为0的顶点
29 
30     stact=(int *)malloc(GL->numVertexes*sizeof(int));
31 
32     for(i=0;i<GL->numVertexes;i++){
33         if(0==GL->adjList[i].in){
34             stack[++top]=i;//将度为0的顶点下标入栈
35         }
36     }
37 
38     while(0!=top){
39         gettop=stact[top--];//出栈
40         printf("%d -> ",GL->adjList[gettop].data);
41         count++;
42         for(e=GL->adjList[gettop].firstedge;e;e=e->next){
43             k=e->adjvex;
44             //注意：下边这个if条件是分析整个程序的要点
45             //将k号顶点邻接顶的入度-1；由于他的前序已经删除
46             //接着判断-1后入度为是否为0，若是为0则也入栈
47             if(!(--GL->adjList[k].in)){
48                 stack[++top]=k;
49             }
50         }
51     }
52     if(count<GL->numVertexes){//若是count小于顶点数，说明存在环
53         return ERROR;
54     }else{
55         return OK;
56     }
57 }

关键路径

AOE网

　　在一个表示工程的带权有向图中，用顶点表示事件，用有向边表示活动，用边上的权值表示活动的持续时间，这种有向图的边表示活动的网。把没入度的顶点称为始点或源点，没有出度的顶点称为终点或汇点

　　关键路径就是决定整个工程时间的路径；由于工程中有些步骤要在一些步骤完成的基础上才能进行，而有些则不须要，这种没有制约的步骤就能够同时进行，而决定整个整个工程时间的就是这种相互制约的步骤的最长时间和

思路

　　正向求处事件的最先发生时间，和反向求出事件最晚发生时间；而后根据事件的etv、ltv求出活动的ete和lte；【ete==lte的活动，为关键活动，关键活动组成的路径是关键路径】

注：etv和ltv是针对事件的，ete和lte是针对活动的；而且根据etv、ltv和活动须要的时间是能够求出活动ete和lte的；【活动：etv就是弧尾顶点事件的最先发生时间；lte就是弧头顶底事件ltv（最晚时间）-活动所需时间】

• etv：事件最先发生的时间，就是顶点的最先发生时间
• ltv：事件最晚发生时间，每一个顶点对应事件最晚要开始的时间（超过此时间就会影响工程正常进度）【求得etv后根据活动所需时间反向：etv（最先时间）-活动所需时间（这里虽然看似和lte求法类似（一个用最先发生时间减，一个用最晚时间减），但要考虑当这个顶点事件有多条出度时会求出多个ltv，这时就要取那个最小的，而lte就不会有这种顾忌）】
• ete：活动最先开工时间，弧的最先发生时间
• lte：活动的最晚发生时间

  1 #define MAXVEX 10
  2 
  3 //边表结点声明
  4 typedef struct EdgeNode{
  5     int adjvex;
  6     int weight;
  7     struct EdgeNode *next;
  8 }EdgeNode;
  9 
 10 //顶点结点声明
 11 typedef struct VertexNode{
 12     int in;//顶点入度
 13     int data;
 14     EdgeNode *firstedge;
 15 }VertexNode,AdjList[MAXVEX];
 16 
 17 typedef struct{
 18     AdjList adjList;
 19     int numVertexes,numEdges;
 20 }graphAdjList,* GraphAdjList;
 21 
 22 int *etv,ltv;
 23 int *stact2;//用于存储拓扑序列的栈
 24 int top2;//用于stack2的栈顶指针
 25 
 26 //拓扑排序算法
 27 //若GL无回路，则会输入拓扑排序序列并返回OK,不然返回ERROE
 28 Status TopoLogicalSort(GraphAdjList GL){
 29     EdgeNode *e;
 30     int i,k,gettop;
 31     int top=0;//用于栈指针下标索引
 32     int count=0;//用于统计输出顶点的个数
 33     int *stact;//用于存储入度为0的顶点
 34 
 35     stact=(int *)malloc(GL->numVertexes*sizeof(int));
 36 
 37     for(i=0;i<GL->numVertexes;i++){
 38         if(0==GL->adjList[i].in){
 39             stack[++top]=i;//将度为0的顶点下标入栈
 40         }
 41     }
 42 
 43     //初始化etv都为0；
 44     top2=0;
 45     etv=(int *)malloc(GL->numVertexes*sizeof(int));
 46     for(i=0;i<GL->numVertexes;i++){
 47         etv[i]=0;
 48     }
 49     stack2=(int *)malloc(GL->numVertexes*sizeof(int));
 50 
 51     while(0!=top){
 52         gettop=stact[top--];//出栈
 53         //printf("%d -> ",GL->adjList[gettop].data);
 54         stack2[++top2]=gettop;//保存拓扑序列顺序；顶点顺序
 55         count++;
 56 
 57         for(e=GL->adjList[gettop].firstedge;e;e=e->next){//操做边表
 58             k=e->adjvex;
 59             //注意：下边这个if条件是分析整个程序的要点
 60             //将k号顶点邻接顶的入度-1；由于他的前序已经删除
 61             //接着判断-1后入度为是否为0，若是为0则也入栈
 62             if(!(--GL->adjList[k].in)){
 63                 stack[++top]=k;
 64             }
 65 
 66             //这里删除了一个入度为0的点，删除顶点（事件）的最先发生时间+边表顶点之间的弧（活动）的权就是边表顶点（事件）最先发生时间
 67             //可能一个顶点（事件）有多个入度，就是有多个活动完成前提，因此要等这些前提活动都完成了才能够开始顶点（事件），因此这个顶点（事件）最先发生时间要选那个最晚的
 68             if((etv[gettop]+e->weight)>etv[k]){
 69                 etv[k]=etv[gettop]+e->weight;
 70             }
 71         }
 72     }
 73     if(count<GL->numVertexes){//若是count小于顶点数，说明存在环
 74         return ERROR;
 75     }else{
 76         return OK;
 77     }
 78 }
 79 
 80 //求关键路径，GL为有向图；输出GL的各项关键活动
 81 void CriticalPath(GraphAdjList GL){
 82     EdgeNode *e;
 83     int i,gettop,k,j;
 84     int ete,lte;
 85 
 86     //调用改进后的拓扑排序，求出etv和stack2的值
 87     TopoLogicalSort(GL);
 88 
 89     //初始化ltv都为汇点时间；
 90     ltv=(int *)malloc(GL->numVertexes*sizeof(int));
 91     for(i=0;i<GL->numVertexes;i++){
 92         ltv[i]=etv[GL->numVertexes-1];
 93     }
 94 
 95     //从汇点倒过来逐个计算ltv
 96     while(0!=top2){
 97         gettop=stack2[top2--];//注意，第一个出栈的就是汇点
 98         for(e=GL->adjList[gettop].firstedge;e;e=e->next){//操做边表
 99             k=e->adjvex;//弧头顶点★★★
100             //这里的顶点（事件）最晚发生时间为：出度的弧头（顶点）最晚发生时间-弧权（活动延续时间）
101             //固然可能有多个出度，为保证每一个出度活动不延续整个工程，因此要取那个最先的弧（活动）的最晚发生时间
102             if((ltv[k]-e->weight)<ltv[gettop]){
103                 ltv[gettop]=ltv[k]-e->weight;
104             }
105         }
106     }
107 
108     //经过etv和ltv求出ete和lte
109     for(j=0;j<GL->numVertexes;e=e->next){
110         for(e=GL->adjList[j].firstedge;e;e=e->next){//操做边表
111             k=e->adjvex;//弧头顶点
112             //弧（活动）最先发生时间就是弧尾顶点（事件）最先发生时间
113             ete=etv[j];
114             //弧（活动）最晚发生时间就是：弧头顶点（事件）最晚发生时间-弧权（活动延续时间）
115             lte=ltv[k]-e->weight;
116 
117             if(ete==lte){//活动的最先发生时间==活动的最晚发生时间为关键活动，关键活动组成的路径为关键路径
118                 printf("<V%d,V%d>length:%d  ",GL->adjList[j].data,GL->adjList[k].data,e->weight);
119             }
120         }
121     }
122 }