拓扑排序和关键路径

最新推荐文章于 2023-08-23 23:27:31 发布
最新推荐文章于 2023-08-23 23:27:31 发布
阅读量813 收藏 3
点赞数 3
分类专栏： C语言 数据结构 图的知识点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yang13563758128/article/details/85131751
版权

一：拓扑排序

前面讲过拓扑排序只是简单的描述，下面具体的实现。

用顶点表示活动，用弧表示活动间的优先关系的有向图为AOV网。

AOV网中没有环，检测的办法是进行拓扑排序。

步骤：

 

(1)在有向图中选一个没有前驱的顶点且输出之。

(2)从图中删除该顶点和所有以它为尾的弧。

重复上述两步，直至全部顶点均已输出，或者当前图中不存在无前驱的顶点为止。另一种情况则说明有向图中存在环。


以有向图为例，图中,V1和V6没有前驱，则可任选一个。假设先输出V6，在删除V6及弧<V6,V4>，<V6,V5>之后，只有顶点V1没有

前驱，则输出V1且删去V1及弧<V1,V2>,<V1,V3>,<V1,V4>之后V3和V4都没有前驱。依次类推,可从中任选一个继续进行。整个拓扑

排序的过程如图7.28所示。最后得到该有向图的拓扑有序序列为:
V6-V1-V4-V3-V2-V5

 

具体代码用C语言实现如下：

 #include<string.h>
 #include<ctype.h>
 #include<malloc.h> /* malloc()等 */
 #include<limits.h> /* INT_MAX等 */
 #include<stdio.h> /* EOF(=^Z或F6),NULL */
 #include<stdlib.h> /* atoi() */
 #include<io.h> /* eof() */
 #include<math.h> /* floor(),ceil(),abs() */
 #include<process.h> /* exit() */
 /* 函数结果状态代码 */
 #define TRUE 1
 #define FALSE 0
 #define OK 1
 #define ERROR 0
 #define INFEASIBLE -1
 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
 typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
 #define MAX_NAME 5 /* 顶点字符串的最大长度 */
 typedef int InfoType;
 typedef char VertexType[MAX_NAME]; /* 字符串类型 */
 /* 图的邻接表存储表示 */
 #define MAX_VERTEX_NUM 20
 typedef enum{DG,DN,AG,AN}GraphKind; /* {有向图,有向网,无向图,无向网} */
 typedef struct ArcNode
 {
   int adjvex; /* 该弧所指向的顶点的位置 */
   struct ArcNode *nextarc; /* 指向下一条弧的指针 */
   InfoType *info; /* 网的权值指针） */
 }ArcNode; /* 表结点 */
 typedef struct
 {
   VertexType data; /* 顶点信息 */
   ArcNode *firstarc; /* 第一个表结点的地址,指向第一条依附该顶点的弧的指针 */
 }VNode,AdjList[MAX_VERTEX_NUM]; /* 头结点 */
 typedef struct
 {
   AdjList vertices;
   int vexnum,arcnum; /* 图的当前顶点数和弧数 */
   int kind; /* 图的种类标志 */
 }ALGraph;

 /* 图的邻接表存储的基本操作(15个) */
 int LocateVex(ALGraph G,VertexType u)
 { /* 初始条件: 图G存在,u和G中顶点有相同特征 */
   /* 操作结果: 若G中存在顶点u,则返回该顶点在图中位置;否则返回-1 */
   int i;
   for(i=0;i<G.vexnum;++i)
     if(strcmp(u,G.vertices[i].data)==0)    //比较顶点是否相等
       return i;
   return -1;
 }

 Status CreateGraph(ALGraph *G)
 { /* 采用邻接表存储结构,构造没有相关信息的图G(用一个函数构造4种图) */
   int i,j,k;
   int w; /* 权值 */
   VertexType va,vb;
   ArcNode *p;
   printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
   scanf("%d",&(*G).kind);
   printf("请输入图的顶点数,边数: ");
   scanf("%d,%d",&(*G).vexnum,&(*G).arcnum);
   printf("请输入%d个顶点的值(<%d个字符):\n",(*G).vexnum,MAX_NAME);
   for(i=0;i<(*G).vexnum;++i) /* 构造顶点向量 */
   {
     scanf("%s",(*G).vertices[i].data);
     (*G).vertices[i].firstarc=NULL;
   }
   if((*G).kind==1||(*G).kind==3) /* 网 */
     printf("请顺序输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):\n");
   else /* 图 */
     printf("请顺序输入每条弧(边)的弧尾和弧头(以空格作为间隔):\n");
   for(k=0;k<(*G).arcnum;++k) /* 构造表结点链表 */
   {
     if((*G).kind==1||(*G).kind==3) /* 网 */
       scanf("%d%s%s",&w,va,vb);
     else /* 图 */
       scanf("%s%s",va,vb);
     i=LocateVex(*G,va); /* 弧尾 */
     j=LocateVex(*G,vb); /* 弧头 */
     p=(ArcNode*)malloc(sizeof(ArcNode));
     p->adjvex=j;
     if((*G).kind==1||(*G).kind==3) /* 网 */
     {
       p->info=(int *)malloc(sizeof(int));
       *(p->info)=w;                         //网的权值指针
     }
     else
       p->info=NULL; /* 图 */
     p->nextarc=(*G).vertices[i].firstarc; /* 插在表头 */
     (*G).vertices[i].firstarc=p;
     if((*G).kind>=2) /* 无向图或网,产生第二个表结点 */
     {
       p=(ArcNode*)malloc(sizeof(ArcNode));
       p->adjvex=i;
       if((*G).kind==3) /* 无向网 */
       {
         p->info=(int*)malloc(sizeof(int));
         *(p->info)=w;
       }
       else
         p->info=NULL; /* 无向图 */
       p->nextarc=(*G).vertices[j].firstarc; /* 插在表头 */
       (*G).vertices[j].firstarc=p;
     }
   }
   return OK;
 }

 void DestroyGraph(ALGraph *G)
 { /* 初始条件: 图G存在。操作结果: 销毁图G */
   int i;
   ArcNode *p,*q;
   (*G).vexnum=0;
   (*G).arcnum=0;
   for(i=0;i<(*G).vexnum;++i)
   {
     p=(*G).vertices[i].firstarc;                 //第一个表结点的地址，头结点
     while(p)
     {
       q=p->nextarc;
       if((*G).kind%2) /* 网 */
         free(p->info);
       free(p);
       p=q;
     }
   }
 }

 VertexType* GetVex(ALGraph G,int v)
 { /* 初始条件: 图G存在,v是G中某个顶点的序号。操作结果: 返回v的值 */
   if(v>=G.vexnum||v<0)
     exit(ERROR);
   return &G.vertices[v].data;
 }

 Status PutVex(ALGraph *G,VertexType v,VertexType value)
 { /* 初始条件: 图G存在,v是G中某个顶点 */
   /* 操作结果: 对v赋新值value */
   int i;
   i=LocateVex(*G,v);               //先找到该顶点
   if(i>-1) /* v是G的顶点 */
   {
     strcpy((*G).vertices[i].data,value);
     return OK;
   }
   return ERROR;
 }

 int FirstAdjVex(ALGraph G,VertexType v)
 { /* 初始条件: 图G存在,v是G中某个顶点 */
   /* 操作结果: 返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点,则返回-1 */
   ArcNode *p;
   int v1;
   v1=LocateVex(G,v); /* v1为顶点v在图G中的序号 */
   p=G.vertices[v1].firstarc;
   if(p)
     return p->adjvex;
   else
     return -1;
 }

 int NextAdjVex(ALGraph G,VertexType v,VertexType w)
 { /* 初始条件: 图G存在,v是G中某个顶点,w是v的邻接顶点 */
   /* 操作结果: 返回v的(相对于w的)下一个邻接顶点的序号。 */
   /*           若w是v的最后一个邻接点,则返回-1 */
   ArcNode *p;
   int v1,w1;
   v1=LocateVex(G,v); /* v1为顶点v在图G中的序号 */
   w1=LocateVex(G,w); /* w1为顶点w在图G中的序号 */
   p=G.vertices[v1].firstarc;
   while(p&&p->adjvex!=w1) /* 指针p不空且所指表结点不是w */
     p=p->nextarc;
   if(!p||!p->nextarc) /* 没找到w或w是最后一个邻接点 */
     return -1;
   else /* p->adjvex==w */
     return p->nextarc->adjvex; /* 返回v的(相对于w的)下一个邻接顶点的序号 */
 }

 void InsertVex(ALGraph *G,VertexType v)
 { /* 初始条件: 图G存在,v和图中顶点有相同特征 */
   /* 操作结果: 在图G中增添新顶点v(不增添与顶点相关的弧,留待InsertArc()去做) */
   strcpy((*G).vertices[(*G).vexnum].data,v); /* 构造新顶点向量 */
   (*G).vertices[(*G).vexnum].firstarc=NULL;
   (*G).vexnum++; /* 图G的顶点数加1 */
 }

 Status DeleteVex(ALGraph *G,VertexType v)
 { /* 初始条件: 图G存在,v是G中某个顶点 */
   /* 操作结果: 删除G中顶点v及其相关的弧 */
   int i,j;
   ArcNode *p,*q;
   j=LocateVex(*G,v); /* j是顶点v的序号 */
   if(j<0) /* v不是图G的顶点 */
     return ERROR;
   p=(*G).vertices[j].firstarc; /* 删除以v为出度的弧或边 */
   while(p)
   {
     q=p;
     p=p->nextarc;
     if((*G).kind%2) /* 网 */
       free(q->info);
     free(q);
     (*G).arcnum--; /* 弧或边数减1 */
   }
   (*G).vexnum--; /* 顶点数减1 */
   for(i=j;i<(*G).vexnum;i++) /* 顶点v后面的顶点前移 */
     (*G).vertices[i]=(*G).vertices[i+1];
   for(i=0;i<(*G).vexnum;i++) /* 删除以v为入度的弧或边且必要时修改表结点的顶点位置值 */
   {
     p=(*G).vertices[i].firstarc; /* 指向第1条弧或边 */
     while(p) /* 有弧 */
     {
       if(p->adjvex==j)
       {
         if(p==(*G).vertices[i].firstarc) /* 待删结点是第1个结点 */
         {
           (*G).vertices[i].firstarc=p->nextarc;
           if((*G).kind%2) /* 网 */
             free(p->info);
           free(p);
           p=(*G).vertices[i].firstarc;
           if((*G).kind<2) /* 有向 */
             (*G).arcnum--; /* 弧或边数减1 */
         }
         else
         {
           q->nextarc=p->nextarc;
           if((*G).kind%2) /* 网 */
             free(p->info);
           free(p);
           p=q->nextarc;
           if((*G).kind<2) /* 有向 */
             (*G).arcnum--; /* 弧或边数减1 */
         }
       }
       else
       {
         if(p->adjvex>j)
           p->adjvex--; /* 修改表结点的顶点位置值(序号) */
         q=p;
         p=p->nextarc;
       }
     }
   }
   return OK;
 }

 Status InsertArc(ALGraph *G,VertexType v,VertexType w)
 { /* 初始条件: 图G存在,v和w是G中两个顶点 */
   /* 操作结果: 在G中增添弧<v,w>,若G是无向的,则还增添对称弧<w,v> */
   ArcNode *p;
   int w1,i,j;
   i=LocateVex(*G,v); /* 弧尾或边的序号 */
   j=LocateVex(*G,w); /* 弧头或边的序号 */
   if(i<0||j<0)
     return ERROR;
   (*G).arcnum++; /* 图G的弧或边的数目加1 */
   if((*G).kind%2) /* 网 */
   {
     printf("请输入弧(边)%s→%s的权值: ",v,w);
     scanf("%d",&w1);
   }
   p=(ArcNode*)malloc(sizeof(ArcNode));
   p->adjvex=j;
   if((*G).kind%2) /* 网 */
   {
     p->info=(int*)malloc(sizeof(int));
     *(p->info)=w1;
   }
   else
     p->info=NULL;
   p->nextarc=(*G).vertices[i].firstarc; /* 插在表头 */
   (*G).vertices[i].firstarc=p;
   if((*G).kind>=2) /* 无向,生成另一个表结点 */
   {
     p=(ArcNode*)malloc(sizeof(ArcNode));
     p->adjvex=i;
     if((*G).kind==3) /* 无向网 */
     {
       p->info=(int*)malloc(sizeof(int));
       *(p->info)=w1;
     }
     else
       p->info=NULL;
     p->nextarc=(*G).vertices[j].firstarc; /* 插在表头 */
     (*G).vertices[j].firstarc=p;
   }
   return OK;
 }

 Status DeleteArc(ALGraph *G,VertexType v,VertexType w)
 { /* 初始条件: 图G存在,v和w是G中两个顶点 */
   /* 操作结果: 在G中删除弧<v,w>,若G是无向的,则还删除对称弧<w,v> */
   ArcNode *p,*q;
   int i,j;
   i=LocateVex(*G,v); /* i是顶点v(弧尾)的序号 */
   j=LocateVex(*G,w); /* j是顶点w(弧头)的序号 */
   if(i<0||j<0||i==j)
     return ERROR;
   p=(*G).vertices[i].firstarc; /* p指向顶点v的第一条出弧 */
   while(p&&p->adjvex!=j) /* p不空且所指之弧不是待删除弧<v,w> */
   { /* p指向下一条弧 */
     q=p;
     p=p->nextarc;
   }
   if(p&&p->adjvex==j) /* 找到弧<v,w> */
   {
     if(p==(*G).vertices[i].firstarc) /* p所指是第1条弧 */
       (*G).vertices[i].firstarc=p->nextarc; /* 指向下一条弧 */
     else
       q->nextarc=p->nextarc; /* 指向下一条弧 */
     if((*G).kind%2) /* 网 */
       free(p->info);
     free(p); /* 释放此结点 */
     (*G).arcnum--; /* 弧或边数减1 */
   }
   if((*G).kind>=2) /* 无向,删除对称弧<w,v> */
   {
     p=(*G).vertices[j].firstarc; /* p指隙サ鉾的第一条出弧 */
     while(p&&p->adjvex!=i) /* p不空且所指之弧不是待删除弧<w,v> */
     { /* p指向下一条弧 */
       q=p;
       p=p->nextarc;
     }
     if(p&&p->adjvex==i) /* 找到弧<w,v> */
     {
       if(p==(*G).vertices[j].firstarc) /* p所指是第1条弧 */
         (*G).vertices[j].firstarc=p->nextarc; /* 指向下一条弧 */
       else
         q->nextarc=p->nextarc; /* 指向下一条弧 */
       if((*G).kind==3) /* 无向网 */
         free(p->info);
       free(p); /* 释放此结点 */
     }
   }
   return OK;
 }

 Boolean visited[MAX_VERTEX_NUM]; /* 访问标志数组(全局量) */
 void(*VisitFunc)(char* v); /* 函数变量(全局量) */
 void DFS(ALGraph G,int v)
 { /* 从第v个顶点出发递归地深度优先遍历图G。算法7.5 */
   int w;
   VertexType v1,w1;
   strcpy(v1,*GetVex(G,v));
   visited[v]=TRUE; /* 设置访问标志为TRUE(已访问) */
   VisitFunc(G.vertices[v].data); /* 访问第v个顶点 */
   for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,strcpy(w1,*GetVex(G,w))))
     if(!visited[w])
       DFS(G,w); /* 对v的尚未访问的邻接点w递归调用DFS */
 }

 void DFSTraverse(ALGraph G,void(*Visit)(char*))
 { /* 对图G作深度优先遍历。算法7.4 */
   int v;
   VisitFunc=Visit; /* 使用全局变量VisitFunc,使DFS不必设函数指针参数 */
   for(v=0;v<G.vexnum;v++)
     visited[v]=FALSE; /* 访问标志数组初始化 */
   for(v=0;v<G.vexnum;v++)
     if(!visited[v])
       DFS(G,v); /* 对尚未访问的顶点调用DFS */
   printf("\n");
 }

 typedef int QElemType; /* 队列类型 */
 /* c3-2.h 单链队列－－队列的链式存储结构 */
 typedef struct QNode
 {
   QElemType data;
   struct QNode *next;
 }QNode,*QueuePtr;

 typedef struct
 {
   QueuePtr front,rear; /* 队头、队尾指针 */
 }LinkQueue;
/* bo3-2.c 链队列(存储结构由c3-2.h定义)的基本操作(9个) */
 Status InitQueue(LinkQueue *Q)
 { /* 构造一个空队列Q */
   (*Q).front=(*Q).rear=(QueuePtr)malloc(sizeof(QNode));
   if(!(*Q).front)
     exit(OVERFLOW);
   (*Q).front->next=NULL;
   return OK;
 }

 Status DestroyQueue(LinkQueue *Q)
 { /* 销毁队列Q(无论空否均可) */
   while((*Q).front)
   {
     (*Q).rear=(*Q).front->next;
     free((*Q).front);
     (*Q).front=(*Q).rear;
   }
   return OK;
 }

 Status ClearQueue(LinkQueue *Q)
 { /* 将Q清为空队列 */
   QueuePtr p,q;
   (*Q).rear=(*Q).front;
   p=(*Q).front->next;
   (*Q).front->next=NULL;
   while(p)
   {
     q=p;
     p=p->next;
     free(q);
   }
   return OK;
 }

 Status QueueEmpty(LinkQueue Q)
 { /* 若Q为空队列,则返回TRUE,否则返回FALSE */
   if(Q.front==Q.rear)
     return TRUE;
   else
     return FALSE;
 }

 int QueueLength(LinkQueue Q)
 { /* 求队列的长度 */
   int i=0;
   QueuePtr p;
   p=Q.front;
   while(Q.rear!=p)
   {
     i++;
     p=p->next;
   }
   return i;
 }

 Status GetHead_Q(LinkQueue Q,QElemType *e) /* 避免与bo2-6.c重名 */
 { /* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
   QueuePtr p;
   if(Q.front==Q.rear)
     return ERROR;
   p=Q.front->next;
   *e=p->data;
   return OK;
 }

 Status EnQueue(LinkQueue *Q,QElemType e)
 { /* 插入元素e为Q的新的队尾元素 */
   QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
   if(!p) /* 存储分配失败 */
     exit(OVERFLOW);
   p->data=e;
   p->next=NULL;
   (*Q).rear->next=p;
   (*Q).rear=p;
   return OK;
 }

 Status DeQueue(LinkQueue *Q,QElemType *e)
 { /* 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */
   QueuePtr p;
   if((*Q).front==(*Q).rear)
     return ERROR;
   p=(*Q).front->next;
   *e=p->data;
   (*Q).front->next=p->next;
   if((*Q).rear==p)
     (*Q).rear=(*Q).front;
   free(p);
   return OK;
 }

 Status QueueTraverse(LinkQueue Q,void(*vi)(QElemType))
 { /* 从队头到队尾依次对队列Q中每个元素调用函数vi()。一旦vi失败,则操作失败 */
   QueuePtr p;
   p=Q.front->next;
   while(p)
   {
     vi(p->data);
     p=p->next;
   }
   printf("\n");
   return OK;
 }









 void BFSTraverse(ALGraph G,void(*Visit)(char*))
 {/*按广度优先非递归遍历图G。使用辅助队列Q和访问标志数组visited。算法7.6 */
   int v,u,w;
   VertexType u1,w1;
   LinkQueue Q;
   for(v=0;v<G.vexnum;++v)
     visited[v]=FALSE; /* 置初值 */
   InitQueue(&Q); /* 置空的辅助队列Q */
   for(v=0;v<G.vexnum;v++) /* 如果是连通图,只v=0就遍历全图 */
     if(!visited[v]) /* v尚未访问 */
     {
       visited[v]=TRUE;
       Visit(G.vertices[v].data);
       EnQueue(&Q,v); /* v入队列 */
       while(!QueueEmpty(Q)) /* 队列不空 */
       {
         DeQueue(&Q,&u); /* 队头元素出队并置为u */
         strcpy(u1,*GetVex(G,u));
         for(w=FirstAdjVex(G,u1);w>=0;w=NextAdjVex(G,u1,strcpy(w1,*GetVex(G,w))))
           if(!visited[w]) /* w为u的尚未访问的邻接顶点 */
           {
             visited[w]=TRUE;
             Visit(G.vertices[w].data);
             EnQueue(&Q,w); /* w入队 */
           }
       }
     }
   printf("\n");
 }

 void Display(ALGraph G)
 { /* 输出图的邻接矩阵G */
   int i;
   ArcNode *p;
   switch(G.kind)
   {
     case DG: printf("有向图\n");
              break;
     case DN: printf("有向网\n");
              break;
     case AG: printf("无向图\n");
              break;
     case AN: printf("无向网\n");
   }
   printf("%d个顶点：\n",G.vexnum);
   for(i=0;i<G.vexnum;++i)
     printf("%s ",G.vertices[i].data);
   printf("\n%d条弧(边):\n",G.arcnum);
   for(i=0;i<G.vexnum;i++)
   {
     p=G.vertices[i].firstarc;
     while(p)
     {
       if(G.kind<=1) /* 有向 */
       {
         printf("%s→%s ",G.vertices[i].data,G.vertices[p->adjvex].data);
         if(G.kind==DN) /* 网 */
           printf(":%d ",*(p->info));
       }
       else /* 无向(避免输出两次) */
       {
         if(i<p->adjvex)
         {
           printf("%s－%s ",G.vertices[i].data,G.vertices[p->adjvex].data);
           if(G.kind==AN) /* 网 */
             printf(":%d ",*(p->info));
         }
       }
       p=p->nextarc;
     }
     printf("\n");
   }
 }


 void FindInDegree(ALGraph G,int indegree[])
 { /* 求顶点的入度，算法7.12、7.13调用 */
   int i;
   ArcNode *p;
   for(i=0;i<G.vexnum;i++)
     indegree[i]=0; /* 赋初值 */
   for(i=0;i<G.vexnum;i++)
   {
     p=G.vertices[i].firstarc;
     while(p)
     {
       indegree[p->adjvex]++;
       p=p->nextarc;
     }
   }
 }

 typedef int SElemType; /* 栈类型 */
 #define STACK_INIT_SIZE 10 /* 存储空间初始分配量 */
 #define STACKINCREMENT 2 /* 存储空间分配增量 */
 typedef struct SqStack
 {
   SElemType *base; /* 在栈构造之前和销毁之后，base的值为NULL */
   SElemType *top; /* 栈顶指针 */
   int stacksize; /* 当前已分配的存储空间，以元素为单位 */
 }SqStack; /* 顺序栈 */
   /*  顺序栈的基本操作（9个） */
 Status InitStack(SqStack *S)
 { /* 构造一个空栈S */
   (*S).base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
   if(!(*S).base)
     exit(OVERFLOW); /* 存储分配失败 */
   (*S).top=(*S).base;
   (*S).stacksize=STACK_INIT_SIZE;
   return OK;
 }

 Status DestroyStack(SqStack *S)
 { /* 销毁栈S，S不再存在 */
   free((*S).base);
   (*S).base=NULL;
   (*S).top=NULL;
   (*S).stacksize=0;
   return OK;
 }

 Status ClearStack(SqStack *S)
 { /* 把S置为空栈 */
   (*S).top=(*S).base;
   return OK;
 }

 Status StackEmpty(SqStack S)
 { /* 若栈S为空栈，则返回TRUE，否则返回FALSE */
   if(S.top==S.base)
     return TRUE;
   else
     return FALSE;
 }

 int StackLength(SqStack S)
 { /* 返回S的元素个数，即栈的长度 */
   return S.top-S.base;
 }

 Status GetTop(SqStack S,SElemType *e)
 { /* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
   if(S.top>S.base)
   {
     *e=*(S.top-1);
     return OK;
   }
   else
     return ERROR;
 }

 Status Push(SqStack *S,SElemType e)
 { /* 插入元素e为新的栈顶元素 */
   if((*S).top-(*S).base>=(*S).stacksize) /* 栈满，追加存储空间 */
   {
     (*S).base=(SElemType *)realloc((*S).base,((*S).stacksize+STACKINCREMENT)*sizeof(SElemType));
     if(!(*S).base)
       exit(OVERFLOW); /* 存储分配失败 */
     (*S).top=(*S).base+(*S).stacksize;
     (*S).stacksize+=STACKINCREMENT;
   }
   *((*S).top)++=e;
   return OK;
 }

 Status Pop(SqStack *S,SElemType *e)
 { /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
   if((*S).top==(*S).base)
     return ERROR;
   *e=*--(*S).top;
   return OK;
 }

 Status StackTraverse(SqStack S,Status(*visit)(SElemType))
 { /* 从栈底到栈顶依次对栈中每个元素调用函数visit()。 */
   /* 一旦visit()失败，则操作失败 */
   while(S.top>S.base)
     visit(*S.base++);
   printf("\n");
   return OK;
 }







 Status TopologicalSort(ALGraph G)
 { /* 有向图G采用邻接表存储结构。若G无回路,则输出G的顶点的一个拓扑序列并返回OK, */
   /* 否则返回ERROR。算法7.12 */
   int i,k,count,indegree[MAX_VERTEX_NUM];
   SqStack S;
   ArcNode *p;
   FindInDegree(G,indegree); /* 对各顶点求入度indegree[0..vernum-1] */
   InitStack(&S); /* 初始化栈 */
   for(i=0;i<G.vexnum;++i) /* 建零入度顶点栈S */
     if(!indegree[i])
       Push(&S,i); /* 入度为0者进栈 */
   count=0; /* 对输出顶点计数 */
   while(!StackEmpty(S))
   { /* 栈不空 */
     Pop(&S,&i);
     printf("%s ",G.vertices[i].data); /* 输出i号顶点并计数 */
     ++count;
     for(p=G.vertices[i].firstarc;p;p=p->nextarc)
     { /* 对i号顶点的每个邻接点的入度减1 */
       k=p->adjvex;
       if(!(--indegree[k])) /* 若入度减为0,则入栈 */
         Push(&S,k);
     }
   }
   if(count<G.vexnum)
   {
     printf("此有向图有回路\n");
     return ERROR;
   }
   else
   {
     printf("为一个拓扑序列。\n");
     return OK;
   }
 }

 void main()
 {
   ALGraph f;
   printf("请选择有向图\n");
   CreateGraph(&f);
   Display(f);
   TopologicalSort(f);
 }

 

 

二：关键路径

 

与AOV网对应的是AOE网，即用边表示活动的网，AOE网是一个带权的有向无环图，顶点表示事件，弧表示活动，权表示活动持续的时间。通常用AOE网估计工程的完成时间。

由于在AOE网中有些活动可以并行的进行，所以完成工程的最短时间是从开始点到完成点的最长路径的长度。路径最长的叫关键路径，我们用e(i)表示活动最早开始时间，l(i)表示最迟开始时间。两者之差l(i)一e(i)意味着完成活动a的时间余量。我们把l(i)=e(i)的活动叫做关键活动。显然;关键路径上的所有活动都是关键活动，因此提前完成非关键活动并不能加快工程的进度。

用代码C语言实现如下：

#include<string.h>
 #include<ctype.h>
 #include<malloc.h> /* malloc()等 */
 #include<limits.h> /* INT_MAX等 */
 #include<stdio.h> /* EOF(=^Z或F6),NULL */
 #include<stdlib.h> /* atoi() */
 #include<io.h> /* eof() */
 #include<math.h> /* floor(),ceil(),abs() */
 #include<process.h> /* exit() */
 /* 函数结果状态代码 */
 #define TRUE 1
 #define FALSE 0
 #define OK 1
 #define ERROR 0
 #define INFEASIBLE -1
 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
 typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
 #define MAX_NAME 5 /* 顶点字符串的最大长度 */
 typedef int InfoType;
 typedef char VertexType[MAX_NAME]; /* 字符串类型 */
 /* c7-2.h 图的邻接表存储表示 */
 #define MAX_VERTEX_NUM 20
 typedef enum{DG,DN,AG,AN}GraphKind; /* {有向图,有向网,无向图,无向网} */
 typedef struct ArcNode
 {
   int adjvex; /* 该弧所指向的顶点的位置 */
   struct ArcNode *nextarc; /* 指向下一条弧的指针 */
   InfoType *info; /* 网的权值指针） */
 }ArcNode; /* 表结点 */
 typedef struct
 {
   VertexType data; /* 顶点信息 */
   ArcNode *firstarc; /* 第一个表结点的地址,指向第一条依附该顶点的弧的指针 */
 }VNode,AdjList[MAX_VERTEX_NUM]; /* 头结点 */
 typedef struct
 {
   AdjList vertices;
   int vexnum,arcnum; /* 图的当前顶点数和弧数 */
   int kind; /* 图的种类标志 */
 }ALGraph;

 /* bo7-2.c 图的邻接表存储(存储结构由c7-2.h定义)的基本操作(15个) */
 int LocateVex(ALGraph G,VertexType u)
 { /* 初始条件: 图G存在,u和G中顶点有相同特征 */
   /* 操作结果: 若G中存在顶点u,则返回该顶点在图中位置;否则返回-1 */
   int i;
   for(i=0;i<G.vexnum;++i)
     if(strcmp(u,G.vertices[i].data)==0)
       return i;
   return -1;
 }

 Status CreateGraph(ALGraph *G)
 { /* 采用邻接表存储结构,构造没有相关信息的图G(用一个函数构造4种图) */
   int i,j,k;
   int w; /* 权值 */
   VertexType va,vb;
   ArcNode *p;
   printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
   scanf("%d",&(*G).kind);
   printf("请输入图的顶点数,边数: ");
   scanf("%d,%d",&(*G).vexnum,&(*G).arcnum);
   printf("请输入%d个顶点的值(<%d个字符):\n",(*G).vexnum,MAX_NAME);
   for(i=0;i<(*G).vexnum;++i) /* 构造顶点向量 */
   {
     scanf("%s",(*G).vertices[i].data);
     (*G).vertices[i].firstarc=NULL;
   }
   if((*G).kind==1||(*G).kind==3) /* 网 */
     printf("请顺序输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):\n");
   else /* 图 */
     printf("请顺序输入每条弧(边)的弧尾和弧头(以空格作为间隔):\n");
   for(k=0;k<(*G).arcnum;++k) /* 构造表结点链表 */
   {
     if((*G).kind==1||(*G).kind==3) /* 网 */
       scanf("%d%s%s",&w,va,vb);
     else /* 图 */
       scanf("%s%s",va,vb);
     i=LocateVex(*G,va); /* 弧尾 */
     j=LocateVex(*G,vb); /* 弧头 */
     p=(ArcNode*)malloc(sizeof(ArcNode));
     p->adjvex=j;
     if((*G).kind==1||(*G).kind==3) /* 网 */
     {
       p->info=(int *)malloc(sizeof(int));
       *(p->info)=w;
     }
     else
       p->info=NULL; /* 图 */
     p->nextarc=(*G).vertices[i].firstarc; /* 插在表头 */
     (*G).vertices[i].firstarc=p;
     if((*G).kind>=2) /* 无向图或网,产生第二个表结点 */
     {
       p=(ArcNode*)malloc(sizeof(ArcNode));
       p->adjvex=i;
       if((*G).kind==3) /* 无向网 */
       {
         p->info=(int*)malloc(sizeof(int));
         *(p->info)=w;
       }
       else
         p->info=NULL; /* 无向图 */
       p->nextarc=(*G).vertices[j].firstarc; /* 插在表头 */
       (*G).vertices[j].firstarc=p;
     }
   }
   return OK;
 }

 void DestroyGraph(ALGraph *G)
 { /* 初始条件: 图G存在。操作结果: 销毁图G */
   int i;
   ArcNode *p,*q;
   (*G).vexnum=0;
   (*G).arcnum=0;
   for(i=0;i<(*G).vexnum;++i)
   {
     p=(*G).vertices[i].firstarc;
     while(p)
     {
       q=p->nextarc;
       if((*G).kind%2) /* 网 */
         free(p->info);
       free(p);
       p=q;
     }
   }
 }

 VertexType* GetVex(ALGraph G,int v)
 { /* 初始条件: 图G存在,v是G中某个顶点的序号。操作结果: 返回v的值 */
   if(v>=G.vexnum||v<0)
     exit(ERROR);
   return &G.vertices[v].data;
 }

 Status PutVex(ALGraph *G,VertexType v,VertexType value)
 { /* 初始条件: 图G存在,v是G中某个顶点 */
   /* 操作结果: 对v赋新值value */
   int i;
   i=LocateVex(*G,v);
   if(i>-1) /* v是G的顶点 */
   {
     strcpy((*G).vertices[i].data,value);
     return OK;
   }
   return ERROR;
 }

 int FirstAdjVex(ALGraph G,VertexType v)
 { /* 初始条件: 图G存在,v是G中某个顶点 */
   /* 操作结果: 返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点,则返回-1 */
   ArcNode *p;
   int v1;
   v1=LocateVex(G,v); /* v1为顶点v在图G中的序号 */
   p=G.vertices[v1].firstarc;
   if(p)
     return p->adjvex;
   else
     return -1;
 }

 int NextAdjVex(ALGraph G,VertexType v,VertexType w)
 { /* 初始条件: 图G存在,v是G中某个顶点,w是v的邻接顶点 */
   /* 操作结果: 返回v的(相对于w的)下一个邻接顶点的序号。 */
   /*           若w是v的最后一个邻接点,则返回-1 */
   ArcNode *p;
   int v1,w1;
   v1=LocateVex(G,v); /* v1为顶点v在图G中的序号 */
   w1=LocateVex(G,w); /* w1为顶点w在图G中的序号 */
   p=G.vertices[v1].firstarc;
   while(p&&p->adjvex!=w1) /* 指针p不空且所指表结点不是w */
     p=p->nextarc;
   if(!p||!p->nextarc) /* 没找到w或w是最后一个邻接点 */
     return -1;
   else /* p->adjvex==w */
     return p->nextarc->adjvex; /* 返回v的(相对于w的)下一个邻接顶点的序号 */
 }

 void InsertVex(ALGraph *G,VertexType v)
 { /* 初始条件: 图G存在,v和图中顶点有相同特征 */
   /* 操作结果: 在图G中增添新顶点v(不增添与顶点相关的弧,留待InsertArc()去做) */
   strcpy((*G).vertices[(*G).vexnum].data,v); /* 构造新顶点向量 */
   (*G).vertices[(*G).vexnum].firstarc=NULL;
   (*G).vexnum++; /* 图G的顶点数加1 */
 }

 Status DeleteVex(ALGraph *G,VertexType v)
 { /* 初始条件: 图G存在,v是G中某个顶点 */
   /* 操作结果: 删除G中顶点v及其相关的弧 */
   int i,j;
   ArcNode *p,*q;
   j=LocateVex(*G,v); /* j是顶点v的序号 */
   if(j<0) /* v不是图G的顶点 */
     return ERROR;
   p=(*G).vertices[j].firstarc; /* 删除以v为出度的弧或边 */
   while(p)
   {
     q=p;
     p=p->nextarc;
     if((*G).kind%2) /* 网 */
       free(q->info);
     free(q);
     (*G).arcnum--; /* 弧或边数减1 */
   }
   (*G).vexnum--; /* 顶点数减1 */
   for(i=j;i<(*G).vexnum;i++) /* 顶点v后面的顶点前移 */
     (*G).vertices[i]=(*G).vertices[i+1];
   for(i=0;i<(*G).vexnum;i++) /* 删除以v为入度的弧或边且必要时修改表结点的顶点位置值 */
   {
     p=(*G).vertices[i].firstarc; /* 指向第1条弧或边 */
     while(p) /* 有弧 */
     {
       if(p->adjvex==j)
       {
         if(p==(*G).vertices[i].firstarc) /* 待删结点是第1个结点 */
         {
           (*G).vertices[i].firstarc=p->nextarc;
           if((*G).kind%2) /* 网 */
             free(p->info);
           free(p);
           p=(*G).vertices[i].firstarc;
           if((*G).kind<2) /* 有向 */
             (*G).arcnum--; /* 弧或边数减1 */
         }
         else
         {
           q->nextarc=p->nextarc;
           if((*G).kind%2) /* 网 */
             free(p->info);
           free(p);
           p=q->nextarc;
           if((*G).kind<2) /* 有向 */
             (*G).arcnum--; /* 弧或边数减1 */
         }
       }
       else
       {
         if(p->adjvex>j)
           p->adjvex--; /* 修改表结点的顶点位置值(序号) */
         q=p;
         p=p->nextarc;
       }
     }
   }
   return OK;
 }

 Status InsertArc(ALGraph *G,VertexType v,VertexType w)
 { /* 初始条件: 图G存在,v和w是G中两个顶点 */
   /* 操作结果: 在G中增添弧<v,w>,若G是无向的,则还增添对称弧<w,v> */
   ArcNode *p;
   int w1,i,j;
   i=LocateVex(*G,v); /* 弧尾或边的序号 */
   j=LocateVex(*G,w); /* 弧头或边的序号 */
   if(i<0||j<0)
     return ERROR;
   (*G).arcnum++; /* 图G的弧或边的数目加1 */
   if((*G).kind%2) /* 网 */
   {
     printf("请输入弧(边)%s→%s的权值: ",v,w);
     scanf("%d",&w1);
   }
   p=(ArcNode*)malloc(sizeof(ArcNode));
   p->adjvex=j;
   if((*G).kind%2) /* 网 */
   {
     p->info=(int*)malloc(sizeof(int));
     *(p->info)=w1;
   }
   else
     p->info=NULL;
   p->nextarc=(*G).vertices[i].firstarc; /* 插在表头 */
   (*G).vertices[i].firstarc=p;
   if((*G).kind>=2) /* 无向,生成另一个表结点 */
   {
     p=(ArcNode*)malloc(sizeof(ArcNode));
     p->adjvex=i;
     if((*G).kind==3) /* 无向网 */
     {
       p->info=(int*)malloc(sizeof(int));
       *(p->info)=w1;
     }
     else
       p->info=NULL;
     p->nextarc=(*G).vertices[j].firstarc; /* 插在表头 */
     (*G).vertices[j].firstarc=p;
   }
   return OK;
 }

 Status DeleteArc(ALGraph *G,VertexType v,VertexType w)
 { /* 初始条件: 图G存在,v和w是G中两个顶点 */
   /* 操作结果: 在G中删除弧<v,w>,若G是无向的,则还删除对称弧<w,v> */
   ArcNode *p,*q;
   int i,j;
   i=LocateVex(*G,v); /* i是顶点v(弧尾)的序号 */
   j=LocateVex(*G,w); /* j是顶点w(弧头)的序号 */
   if(i<0||j<0||i==j)
     return ERROR;
   p=(*G).vertices[i].firstarc; /* p指向顶点v的第一条出弧 */
   while(p&&p->adjvex!=j) /* p不空且所指之弧不是待删除弧<v,w> */
   { /* p指向下一条弧 */
     q=p;
     p=p->nextarc;
   }
   if(p&&p->adjvex==j) /* 找到弧<v,w> */
   {
     if(p==(*G).vertices[i].firstarc) /* p所指是第1条弧 */
       (*G).vertices[i].firstarc=p->nextarc; /* 指向下一条弧 */
     else
       q->nextarc=p->nextarc; /* 指向下一条弧 */
     if((*G).kind%2) /* 网 */
       free(p->info);
     free(p); /* 释放此结点 */
     (*G).arcnum--; /* 弧或边数减1 */
   }
   if((*G).kind>=2) /* 无向,删除对称弧<w,v> */
   {
     p=(*G).vertices[j].firstarc; /* p指隙サ鉾的第一条出弧 */
     while(p&&p->adjvex!=i) /* p不空且所指之弧不是待删除弧<w,v> */
     { /* p指向下一条弧 */
       q=p;
       p=p->nextarc;
     }
     if(p&&p->adjvex==i) /* 找到弧<w,v> */
     {
       if(p==(*G).vertices[j].firstarc) /* p所指是第1条弧 */
         (*G).vertices[j].firstarc=p->nextarc; /* 指向下一条弧 */
       else
         q->nextarc=p->nextarc; /* 指向下一条弧 */
       if((*G).kind==3) /* 无向网 */
         free(p->info);
       free(p); /* 释放此结点 */
     }
   }
   return OK;
 }

 Boolean visited[MAX_VERTEX_NUM]; /* 访问标志数组(全局量) */
 void(*VisitFunc)(char* v); /* 函数变量(全局量) */
 void DFS(ALGraph G,int v)
 { /* 从第v个顶点出发递归地深度优先遍历图G。算法7.5 */
   int w;
   VertexType v1,w1;
   strcpy(v1,*GetVex(G,v));
   visited[v]=TRUE; /* 设置访问标志为TRUE(已访问) */
   VisitFunc(G.vertices[v].data); /* 访问第v个顶点 */
   for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,strcpy(w1,*GetVex(G,w))))
     if(!visited[w])
       DFS(G,w); /* 对v的尚未访问的邻接点w递归调用DFS */
 }

 void DFSTraverse(ALGraph G,void(*Visit)(char*))
 { /* 对图G作深度优先遍历。算法7.4 */
   int v;
   VisitFunc=Visit; /* 使用全局变量VisitFunc,使DFS不必设函数指针参数 */
   for(v=0;v<G.vexnum;v++)
     visited[v]=FALSE; /* 访问标志数组初始化 */
   for(v=0;v<G.vexnum;v++)
     if(!visited[v])
       DFS(G,v); /* 对尚未访问的顶点调用DFS */
   printf("\n");
 }

 typedef int QElemType; /* 队列类型 */
/* c3-2.h 单链队列－－队列的链式存储结构 */
 typedef struct QNode
 {
   QElemType data;
   struct QNode *next;
 }QNode,*QueuePtr;

 typedef struct
 {
   QueuePtr front,rear; /* 队头、队尾指针 */
 }LinkQueue;
/* bo3-2.c 链队列(存储结构由c3-2.h定义)的基本操作(9个) */
 Status InitQueue(LinkQueue *Q)
 { /* 构造一个空队列Q */
   (*Q).front=(*Q).rear=(QueuePtr)malloc(sizeof(QNode));
   if(!(*Q).front)
     exit(OVERFLOW);
   (*Q).front->next=NULL;
   return OK;
 }

 Status DestroyQueue(LinkQueue *Q)
 { /* 销毁队列Q(无论空否均可) */
   while((*Q).front)
   {
     (*Q).rear=(*Q).front->next;
     free((*Q).front);
     (*Q).front=(*Q).rear;
   }
   return OK;
 }

 Status ClearQueue(LinkQueue *Q)
 { /* 将Q清为空队列 */
   QueuePtr p,q;
   (*Q).rear=(*Q).front;
   p=(*Q).front->next;
   (*Q).front->next=NULL;
   while(p)
   {
     q=p;
     p=p->next;
     free(q);
   }
   return OK;
 }

 Status QueueEmpty(LinkQueue Q)
 { /* 若Q为空队列,则返回TRUE,否则返回FALSE */
   if(Q.front==Q.rear)
     return TRUE;
   else
     return FALSE;
 }

 int QueueLength(LinkQueue Q)
 { /* 求队列的长度 */
   int i=0;
   QueuePtr p;
   p=Q.front;
   while(Q.rear!=p)
   {
     i++;
     p=p->next;
   }
   return i;
 }

 Status GetHead_Q(LinkQueue Q,QElemType *e) /* 避免与bo2-6.c重名 */
 { /* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
   QueuePtr p;
   if(Q.front==Q.rear)
     return ERROR;
   p=Q.front->next;
   *e=p->data;
   return OK;
 }

 Status EnQueue(LinkQueue *Q,QElemType e)
 { /* 插入元素e为Q的新的队尾元素 */
   QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
   if(!p) /* 存储分配失败 */
     exit(OVERFLOW);
   p->data=e;
   p->next=NULL;
   (*Q).rear->next=p;
   (*Q).rear=p;
   return OK;
 }

 Status DeQueue(LinkQueue *Q,QElemType *e)
 { /* 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */
   QueuePtr p;
   if((*Q).front==(*Q).rear)
     return ERROR;
   p=(*Q).front->next;
   *e=p->data;
   (*Q).front->next=p->next;
   if((*Q).rear==p)
     (*Q).rear=(*Q).front;
   free(p);
   return OK;
 }

 Status QueueTraverse(LinkQueue Q,void(*vi)(QElemType))
 { /* 从队头到队尾依次对队列Q中每个元素调用函数vi()。一旦vi失败,则操作失败 */
   QueuePtr p;
   p=Q.front->next;
   while(p)
   {
     vi(p->data);
     p=p->next;
   }
   printf("\n");
   return OK;
 }








 void BFSTraverse(ALGraph G,void(*Visit)(char*))
 {/*按广度优先非递归遍历图G。使用辅助队列Q和访问标志数组visited。算法7.6 */
   int v,u,w;
   VertexType u1,w1;
   LinkQueue Q;
   for(v=0;v<G.vexnum;++v)
     visited[v]=FALSE; /* 置初值 */
   InitQueue(&Q); /* 置空的辅助队列Q */
   for(v=0;v<G.vexnum;v++) /* 如果是连通图,只v=0就遍历全图 */
     if(!visited[v]) /* v尚未访问 */
     {
       visited[v]=TRUE;
       Visit(G.vertices[v].data);
       EnQueue(&Q,v); /* v入队列 */
       while(!QueueEmpty(Q)) /* 队列不空 */
       {
         DeQueue(&Q,&u); /* 队头元素出队并置为u */
         strcpy(u1,*GetVex(G,u));
         for(w=FirstAdjVex(G,u1);w>=0;w=NextAdjVex(G,u1,strcpy(w1,*GetVex(G,w))))
           if(!visited[w]) /* w为u的尚未访问的邻接顶点 */
           {
             visited[w]=TRUE;
             Visit(G.vertices[w].data);
             EnQueue(&Q,w); /* w入队 */
           }
       }
     }
   printf("\n");
 }

 void Display(ALGraph G)
 { /* 输出图的邻接矩阵G */
   int i;
   ArcNode *p;
   switch(G.kind)
   {
     case DG: printf("有向图\n");
              break;
     case DN: printf("有向网\n");
              break;
     case AG: printf("无向图\n");
              break;
     case AN: printf("无向网\n");
   }
   printf("%d个顶点：\n",G.vexnum);
   for(i=0;i<G.vexnum;++i)
     printf("%s ",G.vertices[i].data);
   printf("\n%d条弧(边):\n",G.arcnum);
   for(i=0;i<G.vexnum;i++)
   {
     p=G.vertices[i].firstarc;
     while(p)
     {
       if(G.kind<=1) /* 有向 */
       {
         printf("%s→%s ",G.vertices[i].data,G.vertices[p->adjvex].data);
         if(G.kind==DN) /* 网 */
           printf(":%d ",*(p->info));
       }
       else /* 无向(避免输出两次) */
       {
         if(i<p->adjvex)
         {
           printf("%s－%s ",G.vertices[i].data,G.vertices[p->adjvex].data);
           if(G.kind==AN) /* 网 */
             printf(":%d ",*(p->info));
         }
       }
       p=p->nextarc;
     }
     printf("\n");
   }
 }










 int ve[MAX_VERTEX_NUM]; /* 全局变量(用于算法7.13和算法7.14) */

 void FindInDegree(ALGraph G,int indegree[])
 { /* 求顶点的入度，算法7.12、7.13调用 */
   int i;
   ArcNode *p;
   for(i=0;i<G.vexnum;i++)
     indegree[i]=0; /* 赋初值 */
   for(i=0;i<G.vexnum;i++)
   {
     p=G.vertices[i].firstarc;
     while(p)
     {
       indegree[p->adjvex]++;
       p=p->nextarc;
     }
   }
 }

 typedef int SElemType; /* 栈类型 */
 #define STACK_INIT_SIZE 10 /* 存储空间初始分配量 */
 #define STACKINCREMENT 2 /* 存储空间分配增量 */
 typedef struct SqStack
 {
   SElemType *base; /* 在栈构造之前和销毁之后，base的值为NULL */
   SElemType *top; /* 栈顶指针 */
   int stacksize; /* 当前已分配的存储空间，以元素为单位 */
 }SqStack; /* 顺序栈 */
   /*  顺序栈的基本操作（9个） */
 Status InitStack(SqStack *S)
 { /* 构造一个空栈S */
   (*S).base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
   if(!(*S).base)
     exit(OVERFLOW); /* 存储分配失败 */
   (*S).top=(*S).base;
   (*S).stacksize=STACK_INIT_SIZE;
   return OK;
 }

 Status DestroyStack(SqStack *S)
 { /* 销毁栈S，S不再存在 */
   free((*S).base);
   (*S).base=NULL;
   (*S).top=NULL;
   (*S).stacksize=0;
   return OK;
 }

 Status ClearStack(SqStack *S)
 { /* 把S置为空栈 */
   (*S).top=(*S).base;
   return OK;
 }

 Status StackEmpty(SqStack S)
 { /* 若栈S为空栈，则返回TRUE，否则返回FALSE */
   if(S.top==S.base)
     return TRUE;
   else
     return FALSE;
 }

 int StackLength(SqStack S)
 { /* 返回S的元素个数，即栈的长度 */
   return S.top-S.base;
 }

 Status GetTop(SqStack S,SElemType *e)
 { /* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
   if(S.top>S.base)
   {
     *e=*(S.top-1);
     return OK;
   }
   else
     return ERROR;
 }

 Status Push(SqStack *S,SElemType e)
 { /* 插入元素e为新的栈顶元素 */
   if((*S).top-(*S).base>=(*S).stacksize) /* 栈满，追加存储空间 */
   {
     (*S).base=(SElemType *)realloc((*S).base,((*S).stacksize+STACKINCREMENT)*sizeof(SElemType));
     if(!(*S).base)
       exit(OVERFLOW); /* 存储分配失败 */
     (*S).top=(*S).base+(*S).stacksize;
     (*S).stacksize+=STACKINCREMENT;
   }
   *((*S).top)++=e;
   return OK;
 }

 Status Pop(SqStack *S,SElemType *e)
 { /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
   if((*S).top==(*S).base)
     return ERROR;
   *e=*--(*S).top;
   return OK;
 }

 Status StackTraverse(SqStack S,Status(*visit)(SElemType))
 { /* 从栈底到栈顶依次对栈中每个元素调用函数visit()。 */
   /* 一旦visit()失败，则操作失败 */
   while(S.top>S.base)
     visit(*S.base++);
   printf("\n");
   return OK;
 }






 Status TopologicalOrder(ALGraph G,SqStack *T)
 { /* 算法7.13  有向网G采用邻接表存储结构,求各顶点事件的最早发生时间ve */
   /* (全局变量)。T为拓扑序列顶点栈,S为零入度顶点栈。若G无回路,则用栈T */
   /* 返回G的一个拓扑序列,且函数值为OK,否则为ERROR */
   int j,k,count,indegree[MAX_VERTEX_NUM];
   SqStack S;
   ArcNode *p;
   FindInDegree(G,indegree);/*对各顶点求入度indegree[0..vernum-1] */
   InitStack(&S); /* 初始化栈 */
   for(j=0;j<G.vexnum;++j) /* 建零入度顶点栈S */
     if(!indegree[j])
       Push(&S,j); /* 入度为0者进栈 */
   InitStack(T); /* 初始化拓扑序列顶点栈 */
   count=0; /* 对输出顶点计数 */
   for(j=0;j<G.vexnum;++j) /* 初始化ve[]=0 (最小值) */
     ve[j]=0;
   while(!StackEmpty(S))
   { /* 栈不空 */
     Pop(&S,&j);
     Push(T,j); /* j号顶点入T栈并计数 */
     ++count;
     for(p=G.vertices[j].firstarc;p;p=p->nextarc)
     { /* 对j号顶点的每个邻接点的入度减1 */
       k=p->adjvex;
       if(--indegree[k]==0) /* 若入度减为0,则入栈 */
         Push(&S,k);
       if(ve[j]+*(p->info)>ve[k])
         ve[k]=ve[j]+*(p->info);
     }
   }
   if(count<G.vexnum)
   {
     printf("此有向网有回路\n");
     return ERROR;
   }
   else
     return OK;
 }

 Status CriticalPath(ALGraph G)
 { /* 算法7.14 G为有向网,输出G的各项关键活动 */
   int vl[MAX_VERTEX_NUM];
   SqStack T;
   int i,j,k,ee,el;
   ArcNode *p;
   char dut,tag;
   if(!TopologicalOrder(G,&T)) /* 产生有向环 */
     return ERROR;
   j=ve[0];
   for(i=1;i<G.vexnum;i++) /* j=Max(ve[]) 完成点的值 */
     if(ve[i]>j)
       j=ve[i];
   for(i=0;i<G.vexnum;i++) /* 初始化顶点事件的最迟发生时间(最大值) */
     vl[i]=j; /* 完成点的最早发生时间 */
   while(!StackEmpty(T)) /* 按拓扑逆序求各顶点的vl值 */
     for(Pop(&T,&j),p=G.vertices[j].firstarc;p;p=p->nextarc)
     {
       k=p->adjvex;
       dut=*(p->info); /* dut<j,k> */
       if(vl[k]-dut<vl[j])
         vl[j]=vl[k]-dut;
     }
   printf(" j  k  dut  ee  el  tag\n");
   for(j=0;j<G.vexnum;++j) /* 求ee,el和关键活动 */
     for(p=G.vertices[j].firstarc;p;p=p->nextarc)
     {
       k=p->adjvex;
       dut=*(p->info);
       ee=ve[j];
       el=vl[k]-dut;
       tag=(ee==el)?'*':' ';
       printf("%2d %2d %3d %3d %3d    %c\n",j,k,dut,ee,el,tag); /* 输出关键活动 */
     }
   printf("关键活动为:\n");
   for(j=0;j<G.vexnum;++j) /* 同上 */
     for(p=G.vertices[j].firstarc;p;p=p->nextarc)
     {
       k=p->adjvex;
       dut=*(p->info);
       if(ve[j]==vl[k]-dut)
         printf("%s→%s\n",G.vertices[j].data,G.vertices[k].data); /* 输出关键活动 */
     }
   return OK;
 }

 void main()
 {
   ALGraph h;
   printf("请选择有向网\n");
   CreateGraph(&h);
   Display(h);
   CriticalPath(h);
 }

算法时间复杂度：O(n+e);

 

lhyangtop
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
拓扑排序以及关键路径
HUNTER_R_的博客
07-17 758
 1. 拓扑排序：用于确定一个图中各个点的依赖关系，在满足依赖关系的情况下形成拓扑序列。 方法：构图并记录每个点的入度，找出入度为0的点用栈储存，然后更新每个点的入度，直到栈为空。 通常来说可以把拓扑序列记录下来，然后用递推来得到每个点的信息，在关键路径里会用到。 2. 关键路径； 用顶点表示事件，边表示活动，即可形成一张AOE网来表示出各个顶点之间的依赖关系。 A
关键路径和拓扑排序
weixin_40534145的博客
03-17 420
文章目录简介几个问题：1. 拓扑排序2. 关键路径 简介 几个问题： 关键路径和拓扑排序求什么？ 求关键路径。拓扑排序是求关键路径中的一环。 关键路径是什么？ 举例来说，比如在造车过程中有如下的活动，那么哪条路径是关键路径呢？ 就是在所有路径中耗时最长的那条：开始——发动机完成——集中——组装完成，这条路径。 如何判断是关键路径？ ete == lte的活动为关键活动，其形成的路径为关键路径。 提示：下附代码，亲测可用 1. 拓扑排序 拓扑排序就是对所有节点进行排序，保证节点的连接顺
图的定义，术语，存储方式和建立
Santer的博客
11-29 628
图的定义和术语 图是由顶点集合和弧的集合组成的。记作 G=(V,E).其中V(G)表示顶点集，E(G)表示弧集。顶点即为数据结构中的数据元素。<v,w>表示从 v 到 w 的一条弧，有方向的弧中，v 表示弧尾或者始点，w 表示弧头或者终点，此时的图称为有向图。(v,w)这样的无序对表示 v 和 w 之间的一条边。此时顶点之间不再强调方向性，称之为无向图。在实际应用中，图的弧或者边往往与具有一定意义的数相关，称这些数为权。带权的无向图和有向图分别称为无向网和有向网。 图中的顶点数为 n ，边或
C语言图的拓扑排序6,数据结构之---C语言实现拓扑排序AOV图
weixin_33172728的博客
05-20 434
//有向图的拓扑排序//杨鑫#include#include#include#define max_name 3#define max_vertex_num 20typedef int infotype;//存放网的权值typedef char vertextype[max_name];//字符串类型typedef enum{dg, dn, ag, an}graphkind;//{有向图，有向网，...
【C++】对随机生成的有向图进行强连通分支分解
lethegods的博客
10-09 879
强连通分量. 有向图强 连通分量 ：在 有向图 G中，如果两个顶点vi,vj间（vi>vj）有一条从vi到vj的有向路径，同时还有一条从vj到vi的有向路径，则称两个顶点 强连通 (strongly connected)。. 如果有向图G的每两个顶点都强连通，称G是一个 强连通图 。. 有向图的极大强连通 子图 ，称为强连通分量。 步骤1：在有向图上运行带时间戳的DFS； 步骤2：在翻转的有向图上按照post值的大小运行DFS
数据结构基础：拓扑排序
Juunnry的博客
11-18 291
对一个有向无环图G进行拓扑排序，是将G中所有的顶点排成一个线性序列，使得图中任意一对顶点u和v，若&lt;u,v&gt;属于E（G），则u在线性序列中出现在v之前。 方法： 1. 在有向图中选取一个没有前驱的顶点输出值 2. 从图中删除该顶点和所有以它为尾的弧 3. 重复上述过程，直到所有顶点均输出 代码: TopoSort.h #ifndef TOPOSORT #define T...
数据结构--图论
CS171_chengl的博客
11-25 892
目录 一、图的基本知识 二、图的存储结构 （1）邻接矩阵 （2）邻接表 三、图的遍历方式 （1）DFS（Deep First Search 深度优先搜索） （2）BFS（Breadth First Search 宽度优先搜索&amp;广度优先搜索） （3）略谈DFS与BFS其他用途 四、图的应用 （1）最小生成树(MST-Minimum Spanning Tree) 1.普...
拓扑排序和关键路径课设
02-08
阅读了《数据结构(C语言)》的经典著作后...本次算法课程设计运用所学的图论的拓扑排序和关键路径，去实现工程中的花费时间和顺利进行问题。拓扑排序主要用于检验工程能否施工，关键路径主要用于看出工程施工时间消耗。
拓扑排序与关键路径.pptx
01-11
拓扑排序与关键路径.pptx拓扑排序与关键路径.pptx拓扑排序与关键路径.pptx拓扑排序与关键路径.pptx拓扑排序与关键路径.pptx拓扑排序与关键路径.pptx拓扑排序与关键路径.pptx拓扑排序与关键路径.pptx拓扑排序与关键...
图的最短路径、拓扑排序和关键路径
05-03
"图的最短路径、拓扑排序和关键路径" 图的最短路径是图论中的一种重要概念，它是指从图的一顶点到另一顶点的路径中，所经过的边的数目最少的那条路径。这种路径也可以称作最短距离或最短路径长度。在无权图中，图的...
数据结构课程设计——拓扑排序和关键路径
05-20
数据结构课程设计中，拓扑排序和关键路径是两个重要的概念，它们在计算机科学和工程领域，尤其是在项目管理和网络优化中具有广泛的应用。 拓扑排序是对有向无环图（DAG，Directed Acyclic Graph）的一种线性排序，...
拓扑排序和关键路径的图形化显示.zip
07-03
数据结构课程设计项目，邻接链表、关键路径以及拓扑排序的图形化显示，主要涉及到的技术有：前端、echarts、electron 给定一个有向图，完成： 建立并显示出它的邻接链表； 对该图进行拓扑排序，显示拓扑排序的结果，...
19.图，图的两种存储结构
qq_54708219的博客
08-23 448
ADT Graph{数据对象V:具有相同特性的数据元素的集合，称为顶点集。数据关系R:R={VR}<v,w>表示从v到w的弧，p(v,w)定义了弧<v,w>的信息（权）}基本操作P:Create_Graph() //图的创建操作。初始条件:无。操作结果:生成一个没有顶点的空图G。GetVex(G,v) //求图中的顶点v的值。初始条件:图G存在，v是图中的一个顶点。操作结果:生成一个没有顶点的空图G。初始条件:V是图的顶点集，VR是图中弧的集合。操作结果:按V和VR的定义构造图G。
拓扑排序及逆拓扑排序
m0_51769031的博客
06-20 7436
拓扑排序其实就是对有向无环图的顶点的一种排序，每个顶点出现且只出现一次。对一个AOV网进行拓扑排序的方法：1、从AOV网中选择一个入度为0的顶点并输出；2、从网中删除该顶点和所有以它为起点的有向边；3、重复1和2直到当前的AOV网为空或当前网中不存在入度为0的顶点为止；该算法中假设使用邻接表作为存储结构： 时间复杂度为：O(|V|+|E|)；若采用邻接矩阵存储时，其时间复杂度为O(|V|^2)；祖先结点的DFS函数结束时间大于子孙结点的DFS函数结束时间，利用DFS求出各顶点结束时间，对于拓扑排序，就是
迪杰斯特拉算法求最短路径（邻接表存储）
qq_53313837的博客
11-30 2535
其实完全可以用邻接矩阵存储，那样更快也跟好理解，这个纯属老师布置的任务。 唯一难点就是初始化D[v]为v00到各个终点v的权值，两层遍历。注释写的很清楚。 //实验十一：用邻接表构建有向图，实现迪杰斯特拉算法，求最短路径： //具体要求： //1. 定义一个有向图类型（以邻接表表示图）。完成 //2. 定义一个函数：通过输入完成有向图的建立（邻接表表示）。完成 //3. 定义一个函数，实现Dijkstra算法 //4. 在main函数里调用2和3中的函数：先建立一个有向图，然后指定起始节点V0，最后输
数据结构——图
weixin_41423494的博客
04-28 1070
一、图的存储结构 1、邻接矩阵 用邻接矩阵表示法表视图，出了一个用于存储邻接矩阵的二维数组外，还需要用一个一位数组来存储顶点信息。 #define MaxInt 32767 //表示极大值 #define MVNum 100 //最大顶点数 typedef char VerTexType; //假设顶点的数据类型为字符型 typedef int Ar...
图的深度优先搜索-递归
千言万语ROOM
05-31 2139
图的深度优先搜索的过程： (1)从图的某个顶点V出发，访问V. (2)找出刚访问过的顶点的第一个未被访问的邻接点，访问该顶点。以该顶点为新顶点，重复此步骤，直到 刚顶点没有未bedi被访问的邻接点为止。 （3）返回前一个访问过的且仍有未被访问的邻接点的顶点，找出该din 顶点的下一个未被访问的邻接点，访问该顶点。 (4)重复步骤（2）和（3），直到图中所有的顶点都被访问过，搜索结束。 例如，上图的深度遍历过程如下： （1）从a顶点出发，访问a。 （2）从a出发，访问第一个未被访问的邻接
【数据结构】图的应用之拓扑排序
WINGREZ‘S BLOG
09-02 1469
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 拓扑排序 由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。 偏序关系：若集合X上的关系R是自...
树的叶子结点与完全二叉树结点计算方法
热门推荐
岁月求索
12-19 13万+
一：完全二叉树中结点问题 分析： 设叶子节点个数为n0,度为1的节点个数为n1,度为2的节点个数为n2 侧有 n0+n1+n2=n (1) 对于二叉树有： n0=n2+1 (2) 由(1)(...
图的拓扑排序和关键路径
最新发布
12-11
拓扑排序是一种对有向无环图进行排序的算法，它可以得到一个有向无环图的线性序列。在拓扑排序中，每个顶点表示一个任务，每个有向边表示一个任务之间的依赖关系，即如果任务A依赖于任务B，则在序列中任务A必须在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lhyangtop

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值