C语言实现关键路径

#include <stdio.h>
#include <stdlib.h>

#define MAX_VALUE 10
#define stackinit 100      //栈存储空间初始分配量 
#define stackincre 10      //栈存储空间分配增量 
#define overflow -2

typedef struct EdgeNode{//边顶点
    int index;//该顶点下标
    int weight;//权重
    struct EdgeNode *next;//存储下一个边顶点
}EdgeNode;

typedef struct HeadNode{//表顶点
    char data;
    EdgeNode *edgeNode;
}HeadNode,AdjacencyList[MAX_VALUE];

typedef struct Graph{//图
    AdjacencyList lists;
    int vexNum;//当前顶点数
    int edgeNum;//当前边数
}Graph;

typedef int Selemtype;
typedef struct {
     int *base;     //在栈构造之前和销毁之后，base的值为NULL 
     int *top;      //栈顶指针 
     int stacksize;       //当前已分配的存储空间量，以元素为单位 
 } seqstack;

int indegree[MAX_VALUE] = {0};
int vl[MAX_VALUE] = {0};
int ve[MAX_VALUE] = {0};
seqstack S, T;

int initstack(seqstack &s)   //构造一个空栈 
{
     s.base=(Selemtype*)malloc(sizeof(Selemtype)*stackinit);
     if (!s.base) 
         return 0;                   //存储分配失败 
     s.top=s.base;
     s.stacksize=stackinit;
     return 1;
 }

int destroystack(seqstack &s)   //销毁栈s，s不再存在 
{
    if (s.base) 
        free(s.base);
    return 1;
}

int clearstack(seqstack &s)   //将s置为空栈 
{
    s.top=s.base;
    return 1;
}

int stackempty(seqstack s)    //若栈s为空栈，则返回1，否则返回0 
{
    return s.top==s.base;
}
int stacklength(seqstack &s)   //返回s的元素个数，即栈的长度 
{
    return s.top-s.base;
}

int gettop(seqstack s,Selemtype &e)     //若栈不空，则用e返回s的栈顶元素，否则返回0 
{
    if (s.top==s.base) 
        return 0;
    e=*(s.top-1);
    return e;
}

int push(seqstack &s,Selemtype e)     //插入元素e为新的栈顶元素 
{
    if (s.top-s.base >= stackinit){     //栈满，追加存储空间 
        s.base = (Selemtype*)realloc(s.base , (s.stacksize+stackincre)*sizeof(Selemtype));
        if(!s.base)                     //存储分配失败 
            exit(overflow);
        s.top= s.base + s.stacksize;
        s.stacksize += stackincre;
}
    *(s.top++) = e;
    return 1;
}

int pop(seqstack &s,Selemtype &e)   //若栈不空，则删除s的栈顶元素，用e返回其值，并返回1；否者返回0 
{                                   //是不是和前面的gettop函数有点像 
    if (s.top==s.base) 
        return 0;
    e=*(--s.top);                   //区别在这 
    return 1;
}

int Print(int t) {                   
    printf (" %d", t);
    return 1;
} 

int stacktraverse(seqstack s,int (*visit)(Selemtype))  
 //从栈底到栈顶依次调用函数visit().一旦visit()失败，则操作失败 
{
    Selemtype  *p;
    p=s.base;
    while  (p!=s.top)
    {
        visit(*p);                    //函数指针 
        p++;
    }
    return 1;
}

int locate(Graph *graph,char ch){            //找到该元素所在的下标
    int i ;
    for(i = 0;i<graph->vexNum;i++){
        if(graph->lists[i].data==ch)
            return i;
    }
    return -1;
}

Graph *createGraph(){                        //构造邻接表图
    Graph *graph;
    char ch;
    graph = (Graph*)malloc(sizeof(Graph));
    graph->edgeNum = 0;
    graph->vexNum = 0;
    printf("输入顶点回车退出输入\n");
    while( (ch=getchar() ) != '\n'){             //构造顶点表
        graph->lists[graph->vexNum].data = ch;
        graph->lists[graph->vexNum].edgeNode = NULL;
        graph->vexNum++;
        printf("输入顶点回车退出输入\n");
        fflush(stdin);
    }
    int i;
    printf("当前输入的顶点数如下:\n");
    for(i = 0;i<graph->vexNum;i++){
        printf("%c  ",graph->lists[i].data);
    }
    printf ("\n");
    printf("输入边数\n");
    scanf("%d",&graph->edgeNum);
    EdgeNode *node;
    for(i = 0;i<graph->edgeNum;i++){        //构造边
        fflush(stdin);
        char valueA, valueB;
        int w;
        printf ("输入Va至Vb的弧\n");
        scanf("%c %c",&valueA,&valueB);           //读入<vA,vB>的弧
        printf ("输入Va至Vb的权值\n");
        scanf ("%d", &w);
        int indexA = locate(graph,valueA);      //查找该顶点所在的下标
        int indexB = locate(graph,valueB);
        //始终在头节点后插入新元素，即链表的头插法
        //有向图
        node = (EdgeNode*)malloc(sizeof(EdgeNode));  //申请空间
        node->index = indexB;
        node->weight = w;                         //权值
        node->next = graph->lists[indexA].edgeNode;  //将新表结点node插入到顶点 vA
        graph->lists[indexA].edgeNode = node;
        indegree[indexB]++;                          //各顶点的入度值 
//        若为无向图，则另外一个表顶点也要插入这条路径的边顶点
//        node = (EdgeNode*)malloc(sizeof(EdgeNode));
//        node->index = indexA;
//        node->next = graph->lists[indexB].edgeNode;
//        graph->lists[indexB].edgeNode = node;
    }
    return graph;
}

//拓扑排序的的改写版 
int TopologicalOrder(Graph *g) { 
//有向图 G采用邻接表存储结构，求各顶点事件的最早发生时间ve（全局变量）
//T为拓扑序列顶点栈，S为零入度顶点栈
//若G无回路，则用栈T返回G的一个拓扑序列，且函数值为1，否则为0 
    int i, j = 0, k, counts;
    EdgeNode *p;
    initstack(S);
    for (i=0; i<g->vexNum; i++)
        if (!indegree[i])
            push(S, i);                //入度为0者进栈 
    initstack(T);
    counts = 0;                        //对入栈顶点计数 
    while(!stackempty(S)) {
        pop(S, j);                            
        push(T, j);                        //j号顶点入T栈并计数 
        counts++;
        for (p=g->lists[j].edgeNode; p; p= p->next) {
            k = p->index;
            if (--indegree[k] == 0)             //对j号顶点的每个邻接点的入度减1，并判断入度是否为0 
                push(S, k);
            if (ve[j] + p->weight > ve[k])
                ve[k] = ve[j] + p->weight;
        }
        j++;
    }
    if (counts < g->vexNum)       //存在回路 
        return 0;
    else
        return 1;
}


void CriticalPath(Graph *g) {
    //G为有向图，输出G的各项关键路径 
    int i, k, dut, j=0, ee[MAX_VALUE], el[MAX_VALUE];     //ee为最早开始时间，el为最迟开始时间 
    EdgeNode *p;
    if (!TopologicalOrder(g)) {
        printf("\n本程序所建立的图有回路不可计算出关键路径\n");  
        printf("将退出本程序\n");  
        return ;
    }
    for (i=0; i<g->vexNum; i++) {     //初始化各顶点的最迟发生时间 
        vl[i] = ve[g->vexNum-1];
    }
    printf ("Ve数组：");
    for (i=0; i<g->vexNum; i++)
        printf ("%d ", ve[i]);        
    printf ("\n");
    while (!stackempty(T))               //按拓扑逆序求各顶点的Vl值 
        for (pop(T, j), p=g->lists[j].edgeNode; p; p = p->next) {
            k = p->index;
            dut = p->weight;
            if (vl[k]-dut < vl[j])
                vl[j] = vl[k] - dut;
        }
        printf ("Vl数组：");   
        for (i=0; i<g->vexNum; i++)
            printf ("%d ", vl[i]);        
        printf ("\n");        
        printf("| 起点 | 终点 | 最早开始时间 | 最迟开始时间 | 差值 | 是否为关键路径 \n");
        i = 0;
        for (j=0; j<g->vexNum; j++) {
            for (p=g->lists[j].edgeNode; p; p=p->next) {
                k = p->index;
                dut = p->weight;
                ee[++i] = ve[j];
                el[i] = vl[k] - dut;
                printf("| %4c | %4c | %12d | %12d | %4d |",g->lists[j].data ,g->lists[k].data ,ee[i],el[i],el[i]-ee[i]);  
                if (ee[i] == el[i]) {
                    printf(" 此弧为关键活动");   
                }
                printf ("\n");
            }
        }
        printf ("关键路径节点是：");
        for (i=0; i<g->vexNum; i++)                  
            if (vl[i] == ve[i])
                printf (" %c", g->lists[i].data);
        printf("\n");         
}

int main()
{
    Graph * p = createGraph();
    CriticalPath(p);
    return 0;
}

/*
输入：
1
2
3
4
5
6

8
1 2
3
1 3
2
2 4
2
3 4
4
2 5
3
3 6
3
4 6
2
5 6
1
*/