关键路径(CriticalPath)算法

 #include <stdio.h>
 #include <stdlib.h>
 #include <malloc.h>
 
 #define MAXVEX 30        //最大顶点数
 #define MAXEDGE 30        //最大边数
 #define INFINITY 65535    //∞
 
 //定义全局变量
 int *etv, *ltv;//事情最早发生和最迟发生指针数组
 int *stack2;//用于存储拓扑排序的栈
 int top2;//用于指向stack2栈指针
 
 /*    邻接矩阵结构    */
 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, AdjList[MAXVEX];
 
 typedef struct
 {
     AdjList adjList;//顶点向量
     int numVertexes, numEdges;//顶点数和边数
 }graphAdjList, *GraphAdjList;
 
 void CreateMGraph(MGraph *G)
 {/*    构建图    */
     int i, j;
 
 //    printf("请输入顶点数和边数：\n");
     G->numVertexes = ;
     G->numEdges = ;
 
     //初始化顶点下标
     for(i=; i<G->numVertexes; i++)
         G->vexs[i] = i;
 
     //初始化矩阵
     for(i=; i<G->numVertexes; i++)
         for(j=; j<G->numVertexes; j++)
             if(i == j)
                 G->arc[i][j] = ;
             else
                 G->arc[i][j] = INFINITY;
 
     //内置输入
     G->arc[][] = ;
     G->arc[][] = ;
     G->arc[][] = ;
     G->arc[][] = ;
     G->arc[][] = ;
     G->arc[][] = ;
     G->arc[][] = ;
     G->arc[][] = ;
     G->arc[][] = ;
     G->arc[][] = ;
     G->arc[][] = ;
     G->arc[][] = ;
     G->arc[][] = ;
 
     return ;
 }
 
 void CreateALGraph(MGraph G, GraphAdjList *GL)
 {/*    利用邻接矩阵，构建邻接表    */
     int i, j;
     EdgeNode *e;
 
     *GL = (GraphAdjList)malloc(sizeof(graphAdjList));//*GL代表主函数的GL指向
     (*GL)->numVertexes = G.numVertexes;/*    读取信息    */
     (*GL)->numEdges = G.numEdges;
 
     //初始化
     for(i=; i<G.numVertexes; i++)
     {
         (*GL)->adjList[i].in = ;
         (*GL)->adjList[i].data = G.vexs[i];//读取顶点下标
         (*GL)->adjList[i].firstedge = NULL;
     }
 
     //构建邻接表
     for(i=; i<G.numVertexes; i++)
         for(j=; j<G.numVertexes; j++)
             if( != G.arc[i][j]  &&  INFINITY > G.arc[i][j])
             {//若存在路径
                 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 ++;//顶点入度+1
             }
     return ;
 }
 
 void TopologicalSort(GraphAdjList GL)
 {/*    拓扑排序    */
     EdgeNode *e;
     int i, gettop, k;
     int top = ;//用于指向stack栈顶
     int count = ;//技术输出
     int *stack;//建栈存储入度位0的顶点
     stack = (int *)malloc(sizeof(int));
     for(i=; i<GL->numVertexes; i++)//把所有入度位0的顶点如stack栈中
         if( == GL->adjList[i].in)
             stack[++top] = i;
 
     etv = (int *)malloc(sizeof(int) * GL->numVertexes);//最早发生etv指针申请空间
     for(i=; i<GL->numVertexes; i++)//初始化最早发生etv数组
         etv[i] = ;
 
     stack2 = (int *)malloc(sizeof(int) * GL->numVertexes);//存储拓扑排序序列
     top2 = ;//用于指向stack2栈顶
     printf("Topological:\t");
     while( != top)
     {//若有顶点入度为0
         gettop = stack[top--];//出栈
         printf("%3d->", GL->adjList[gettop].data);//输出出栈的栈顶的顶点信息
         count ++;//输出记数
 
         stack2[++top2] = gettop;//出栈元素赋给存储拓扑序列栈
 
         for(e=GL->adjList[gettop].firstedge; e; e=e->next)
         {//出栈的栈顶元素若有邻接点
             k = e->adjvex;//邻接点-顶点下标
             if(! (--GL->adjList[k].in))//邻接点顶点下标-1(gettop已指向)，是否入度位0？
                 stack[++top] = k;//是则入stack的栈
 
             /*出栈的最早发生时间值+出栈邻接表的路径  >  出栈邻接表顶点下标的最早发生时间值
               就是v0-v1-v3和v0-v2-v3都是从起点到达汇点，3哪一个路径较远    */
             if((etv[gettop] + e->weight) > etv[k])
                 etv[k] = etv[gettop] + e->weight;
         }
     }
     printf("\n");
 
     if(count < GL->numVertexes)//若有环，则结束程序
         exit(-);
 
     return ;
 }
 
 void CriticalPath(GraphAdjList GL)
 {/*    关键路径    */
     EdgeNode *e;
     int i, gettop, k, j;
     int ete, lte;//最早发生和最迟发生的变量
 
     TopologicalSort(GL);//调用拓扑排序函数
 
     ltv = (int *)malloc(sizeof(int) * GL->numVertexes);//最迟发生指针边表指向申请空间
     for(i=; i<GL->numVertexes; i++)//初始化最迟发生数组
         ltv[i] = etv[GL->numVertexes - ];//起到汇最大值
 
     //输出最早发生数组
     printf("etv:\t\t");
     for(i=; i<GL->numVertexes; i++)
         printf("%3d->", etv[i]);
     printf("\n");
 
     while( != top2)
     {//存放拓扑排序数列
         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;
             /*最晚发生时间值(出stack2(存拓扑排序)栈元素的邻接点顶点下标) - 邻接路径   <    最晚发生数组【出栈元素0】
               用拓扑排序的最长路径 - 邻接路径 < 最晚发生值[出栈元素]*/
         }
     }
 
     printf("ltv:\t\t");//输出最晚值数组
     for(i=; i<GL->numVertexes; i++)
         printf("%3d->", ltv[i]);
     printf("\n");
 
     for(j=; 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 \n", GL->adjList[j].data, GL->adjList[k].data, e->weight);
         }
 
     return ;
 }
 
 int main(void)
 
 {
     MGraph G;
     GraphAdjList GL;
     system("title 关键路径");
     CreateMGraph(&G);
     CreateALGraph(G, &GL);
     CriticalPath(GL);
 
     return ;
 }