数据结构实验-拓扑排序C语言-严蔚敏源码-含栈和图的邻接表

最新推荐文章于 2021-11-14 00:00:00 发布
最新推荐文章于 2021-11-14 00:00:00 发布
阅读量712 收藏 9
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42970433/article/details/102742357
版权

太难了 。

【algo7-4.c】

 /* algo7-4.c 输出有向图的一个拓扑序列。实现算法7.12的程序 */
 #include"c1.h"
 #define MAX_NAME 5 /* 顶点字符串的最大长度 */
 typedef int InfoType;
 typedef char VertexType[MAX_NAME]; /* 字符串类型 */
 #include"c7-2.h"
 #include"bo7-2.c"

 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; /* 栈类型 */
 #include"c3-1.h"
 #include"bo3-1.c"
 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);
 }

【algo3-1.c】栈的实现

/* algo3-1.c 调用算法3.1的程序 */
 typedef int SElemType; /* 定义栈元素类型为整型 */
 #include"c1.h"
 #include"c3-1.h" /* 采用顺序栈 */
 #include"bo3-1.c" /* 利用顺序栈的基本操作 */

 void conversion() /* 算法3.1 */
 { /* 对于输入的任意一个非负十进制整数，打印输出与其等值的八进制数 */
   SqStack s;
   unsigned n; /* 非负整数 */
   SElemType e;
   InitStack(&s); /* 初始化栈 */
   printf("n(>=0)=");
   scanf("%u",&n); /* 输入非负十进制整数n */
   while(n) /* 当n不等于0 */
   {
     Push(&s,n%8); /* 入栈n除以8的余数(8进制的低位) */
     n=n/8;
   }
   while(!StackEmpty(s)) /* 当栈不空 */
   {
     Pop(&s,&e); /* 弹出栈顶元素且赋值给e */
     printf("%d",e); /* 输出e */
   }
   printf("\n");
 }

 void main()
 {
   conversion();
 }

【bo3-1.c】

 /* bo3-1.c 顺序栈（存储结构由c3-1.h定义）的基本操作（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;
 }

【c3-1.h】

 /* c3-1.h 栈的顺序存储表示 */
 #define STACK_INIT_SIZE 10 /* 存储空间初始分配量 */
 #define STACKINCREMENT 2 /* 存储空间分配增量 */
 typedef struct SqStack
 {
   SElemType *base; /* 在栈构造之前和销毁之后，base的值为NULL */
   SElemType *top; /* 栈顶指针 */
   int stacksize; /* 当前已分配的存储空间，以元素为单位 */
 }SqStack; /* 顺序栈 */

【c1.h】

 /* c1.h (程序名) */
 #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
 /* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */
 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
 typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */

【c7-2.h】

/* 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】

 /* 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; /* 队列类型 */
 #include"c3-2.h"
 #include"bo3-2.c"
 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");
   }
 }
奔跑的废柴
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言实现拓扑排序（《数据结构》算法7.12）
LiQiyao的博客
03-05 3014
邻接表+拓扑排序，输出的是无向图的拓扑有序序列。 代码如下：#include #include #include #define MAX_VERTEX_NUM 100 using namespace std; int indegree[MAX_VERTEX_NUM]; stacks; typedef struct ArcNode{ int adjvex;//该边的另一个顶点的位置 stru
拓扑排序的邻接表和栈结合实现
weixin_46390732的博客
05-05 355
有关拓扑排序 Graph.h有关图的构造 private: struct EdgeNode { EdgeNode* next; int dest; int weight; }; struct VexNode { EdgeNode* first=NULL; int data; ...
Java排序算法
AND_YOU_with_ME的博客
04-24 393
Java排序算法了解
c语言实现图的拓扑排序
12-24
C语言实现图的拓扑排序
数据结构 实验4——拓扑排序
m0_57587757的博客
11-14 4979
一、实验名称：拓扑排序 二、实验学时：6学时 三、实验目的 1.理解拓扑排序的特性和算法； 2.通过构造图的邻接表，掌握拓扑排序算法。 四、实验内容(步骤) 1.建立邻接表存储的图； 2.对图进行拓扑排序； 3.输出拓扑排序序列。 实验源代码： #include<iostream> #include<cstring> #include<cstdlib> #define MAXSIZE 10 #define OK 1 #define ERROR
严蔚敏数据结构C语言版本-可运行源码-完全C语言代码实现.zip
最新发布
08-17
严蔚敏数据结构C语言版本_可运行源码_完全C语言代码实现 ----- 毕业设计，课程设计，项目源码均经过助教老师测试，运行无误，欢迎下载交流 ----- 下载后请首先打开README.md文件（如有），某些链接可能需要魔法打开...
商业编程-源码-数据结构(C语言版本)严蔚敏答案.zip
06-23
《数据结构(C语言版本)严蔚敏答案》是针对计算机科学中的核心课程——数据结构的一份参考资料，由著名计算机教育家严蔚敏教授编写。在商业编程领域，掌握数据结构对于提升程序设计能力和解决复杂问题至关重要。这份...
商业编程-源码-严蔚敏：数据结构题集（C语言版）答案.zip
06-23
这份压缩包包含了严蔚敏教授编著的《数据结构》一书中的习题解答，用C语言编写，对于学习数据结构的初学者和专业人士具有极高的参考价值。数据结构是计算机科学的基础课程，它探讨如何有效地组织和存储数据，以便在...
数据结构-C语言版-第二版(严蔚敏)-第3章-栈和队列-答案.doc
12-06
"数据结构-C语言版-第二版(严蔚敏)-第3章-栈和队列-答案.doc" 本资源主要讲解了数据结构中的栈和队列两种基本数据结构。栈是一种后进先出的线性表，队列是一种先进先出的线性表。栈和队列都是基本的数据结构，可以...
《数据结构》(C语言版)严蔚敏著-数据结构实验指导.docx
06-16
"数据结构实验指导" 以下是从给定的文件中提取的知识点： 一、函数 * 函数的概念：函数是一段可以重复使用的代码块，用于实现特定的功能。 * 函数的声明和定义：函数的声明包括函数名、返回类型和参数列表，函数...
数据结构实验报告（图的拓扑排序）
03-21
这个是我的数据结构实验报告，我自己的心血啊！希望对你们有用处吧!
数据结构平时实验 拓扑排序
06-30
数据结构平时实验 拓扑排序算法...仅供参考
VC++2012编程演练数据结构《28》拓扑排序算法
11-20
VC++2012编程演练数据结构《28》拓扑排序算法
拓扑排序 数据结构 c和 C++源程序代码
12-27
拓扑排序 数据结构 c和 C++源程序代码 拓扑排序 数据结构 c和 C++源程序代码
用C语言实现拓扑排序
HXZ_CREATE的博客
06-17 2696
顶点表示活动、边表示活动间先后关系的有向图称做顶点活动网(Activity On Vertex network)，简称AOV网。 拓扑排序实现思路：先把入度为0的结点全部压入栈中，遍历入度为0的结点，把遍历过的结点压入栈中，然后删除以该结点为弧尾的弧和删除该结点。 ...
7-9-有向无环图拓扑排序-图-第7章-《数据结构》课本源码-严蔚敏吴伟民版
weixin_34033624的博客
03-19 131
课本源码部分 第7章  图 - 有向无环图拓扑排序 ——《数据结构》-严蔚敏.吴伟民版        源码使用说明  链接☛☛☛ 《数据结构-C语言版》（严蔚敏,吴伟民版）课本源码+习题集解析使用说明        课本源码合辑  链接☛☛☛ 《数据结构》课本源码合辑        习题集全解析  链接☛☛☛ 《数据结构题集》习题解析合辑          本源码引入的文件  链接☛...
数据结构拓扑排序实验体会_数据结构与算法之拓扑排序_一点课堂（多岸学院）...
weixin_39760689的博客
12-03 424
拓扑排序最小生成树和最短路径可以解决无序的问题，此处的无序指的是对顶点的访问顺序没有要求，但是很多场景对顺序有严格的要求，比如说建造一栋大楼必须先找好施工人员，购买各种材料和准备好各种器械之后才能开始盖楼。或者是拍电影必须先找好演员和各种负责人之后才能开拍。类似这样的场景我们称为AOV网。在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，这样的有向图为顶点表示活动的网，我们称为...
图邻接表C语言实现 拓扑排序
11-26 4350
ALGpraph.h#pragma once /************************************************************************/ /* 图的邻接表存储结构 */ /************************************************************************/ #define
拓扑排序~C语言完整代码
热门推荐
weixin_43268636的博客
05-01 1万+
对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边(u,v)∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。 拿个例子来说，...
基本操作P-数据结构c语言版严蔚敏PPT及相关参考文献总结
在严蔚敏教授的《数据结构(C语言版)》一书中，提供了基本操作P-数据结构c语言版严蔚敏PPT，其中包含了一些常见的图操作。其中，Create_Graph()是一个图的创建操作，它生成了一个没有顶点的空图G。GetVex(G, v)则用于...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值