精华内容
下载资源
问答
  • 有向图的拓扑排序 C语言

    千次阅读 2020-11-04 21:52:43
    } void FindInDegree(ALGraph G,int indegree[])//拓扑排序中所用到的各顶点入度函数 { int i,j; ArcNode *p;//创建一个指针 for(i=0;i;i++)//数组初始化 indegree[i] = 0; for(i=0;i;i++)//遍历整个邻接表 ...

    这里使用我随便画的例子:
    在这里插入图片描述
    这种用顶点表示活动,用弧表示活动间的优先关系的有向图称为顶点表示活动的网(Activity On Vertex Network),简称AOV-网。
    按照我的理解是:AOV-网是不带权值且没有回路的有向图。

    完整代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #define MVNum 100 //最大顶点数 
    #define MAXSIZE 100 //最大栈容量 
    
    void Interrupt(void)//创建一个中断函数 
    {
    	while(1)//用于检测换行符,使函数脱离scanf的连续输出 
    		if(getchar()=='\n')
    			break;
    } 
    
    //导入栈定义 
    typedef struct 
    {
    	int data[MAXSIZE];//静态顺序栈可用的最大容量 
    	int top;//栈顶 
    }SqStack;
    
    void InitStack(SqStack &S)//栈的初始化 
    {
    	S.top = -1;//静态顺序栈中,使S.top=-1便是对栈的初始化 
    }
    
    int Push(SqStack &S,int e)//进栈 
    {
    	if(S.top==MAXSIZE-1)//判断栈是否为满 
    	{
    		printf("栈满!\n");
    		return 0;
    	}
    	S.data[++S.top]=e;//S.top自加一,使S.top=0,使输入的e值导入栈中 
    	return 0; 
    }
    
    bool StackEmpty(SqStack S)//栈的判空操作 
    {
    	if(S.top == -1)//若栈为空返回true,否则为false 
    		return true;
    	else
    		return false;
    }
    
    int Pop(SqStack &S)//使栈顶元素出栈,并返回栈顶元素,且栈长减一 
    {
    	if(StackEmpty(S))//首先先判断栈是否为空 
    	{
    		printf("栈空!\n");
    		return -1;
    	}
    	else 
    		return S.data[S.top--];
    }
    
    //导入邻接矩阵定义 
    typedef struct ArcNode
    {
    	int adjvex;//该边所指向的顶点的位置 
    	struct ArcNode *nextarc;//该向下一条边的指针 
    }ArcNode;
    typedef struct VNode//顶点信息 
    {
    	char data;//顶点名称 
    	ArcNode *firstarc;//指向第一条依附该顶点的边的指针 
    }VNode,AdjList[MVNum];//AdjList表示邻接表类型 
    typedef struct//邻接表 
    {
    	AdjList vertices;
    	int vexnum,arcnum;//图的当前顶点数和边数 
    }ALGraph;
    
    void InitGraph(ALGraph &G)//图的初始化 
    {
    	int i;
    	for(i=0;i<MVNum;i++)
    		G.vertices[i].firstarc = NULL;//使所有的第一个结点都置空,也就是后面设定的尾指针的判空操作 
    }
    
    void CreateGraph(ALGraph &G)//图的创建 
    {
    	int i;//记录次数 
    	char a;//顶点变量 
    	printf("请输入顶点数和边数:");
    	scanf("%d %d",&G.vexnum,&G.arcnum);//顶点数和边数的赋值 
    	Interrupt();//该函数用于检测并吸收换行符 
    	printf("请输入顶点名称(连续输入):");
    	for(i=0;i<G.vexnum;i++)//利用循环输入图中顶点名称 
    	{
    		scanf("%c",&a);
    		G.vertices[i].data = a;//第i个顶点的命名 
    	}
    	Interrupt();//该函数用于检测并吸收换行符
    	char b,c;//顶点变量 
    	int w,j,k;//w为权值变量,j和k是用来记录次数的 
    	for(i=0;i<G.arcnum;i++)//利用循环输入所有边的两个顶点和权值 
    	{
    		printf("请输入边的两个顶点:");
    		scanf("%c %c",&b,&c);//输入 
    		Interrupt();//该函数用于检测并吸收换行符
    		for(j=0;j<G.arcnum;j++)//该操作为书上的函数LocateVex操作 
    		{
    			if(G.vertices[j].data == b)//找到输入的顶点b的位置 
    			break;
    		}
    		for(k=0;k<G.arcnum;k++)
    		{
    			if(G.vertices[k].data == c)//找到输入的顶点c的位置 
    			break;
    		}
    		ArcNode *p1;//创建两个野结点 
    		p1 = (ArcNode*)malloc(sizeof(ArcNode));
    		p1->adjvex = k;
    		p1->nextarc = G.vertices[j].firstarc;//类似于头插法 
    		G.vertices[j].firstarc = p1;//并使头结点永远放在第一位 
    	}
    }
    
    void InputGraph(ALGraph G)//邻接表的输出 
    {
    	int i,j;//记录次数 
    	ArcNode *p;//用于遍历链表 
    	printf("邻接表为:\n");
    	for(i=0;i<G.vexnum;i++)//利用循环输出 
    	{
    		printf("%c",G.vertices[i].data);
    		p = G.vertices[i].firstarc;
    		while(p)//当p为空时,结束循环 
    		{
    			printf(" --> %d",p->adjvex);
    			p = p->nextarc;//p指向p的下一个结点 
    		}	
    		printf("\n");
    	}
    	printf("\n");
    }
    
    void FindInDegree(ALGraph G,int indegree[])//拓扑排序中所用到的各顶点入度函数 
    {
    	int i,j;
    	ArcNode *p;//创建一个指针 
    	for(i=0;i<G.vexnum;i++)//数组初始化 
    		indegree[i] = 0;
    	for(i=0;i<G.vexnum;i++)//遍历整个邻接表 
    	{
    		p = G.vertices[i].firstarc;//指针指向第i个结点的firstarc 
    		while(p != NULL)//判断p是否为空 ,这里和拓扑排序函数中的刚好相反 
    		{
    			j = p->adjvex;
    			indegree[j]++;
    			p = p->nextarc;
    		}
    	}	
    }
    
    bool TopologicalSort(ALGraph G,int topo[])//拓扑排序 
    {
    	int i,m,k;
    	int indegree[G.vexnum];
    	FindInDegree(G,indegree);//求各顶点入度函数 
    	SqStack S;
    	InitStack(S);//引入栈 
    	for(i=0;i<G.vexnum;i++)//遍历各顶点 
    	{
    		if(indegree[i] == 0)//入度为0的顶点进栈 
    			Push(S,i);
    	}
    	m = 0;//对输出顶点计数,初始化为0 
    	ArcNode *p;
    	while(StackEmpty(S) != true)//栈S非空 
    	{
    		i = Pop(S);//出栈,并赋值给i 
    		topo[m] = i;//将Vi保存在拓扑排序数组topo中 
    		m++;//对输出顶点计数 
    		p = G.vertices[i].firstarc;//p指向Vi的第一个邻接点 
    		while(p != NULL)
    		{
    			k = p->adjvex;//Vk为Vi的邻接点 
    			indegree[k]--;//Vi的每个邻接点的入度减1 
    			if(indegree[k] == 0)//若入度减为0,则入栈 
    				Push(S,k);
    			p = p->nextarc;//p指向Vi下一个邻接结点 
    		}
    	}
    	if(m<G.vexnum)//该有向图有回路 
    		return false;
    	else
    		return true;
    }
    
    int main()
    {
    	ALGraph G;
    	InitGraph(G);//初始化 
    	CreateGraph(G);//邻接表的创建 
    	InputGraph(G);//邻接表的输出 
    	int i,a[G.vexnum];
    	if(TopologicalSort(G,a)) //调用拓扑排序,若没有回路函数为true,否则false 
    		for(i=0;i<G.vexnum;i++)//利用循环打印拓扑后的值 
    			printf("%c  ",G.vertices[a[i]].data);
    	else
    		printf("有回路!");
    	return 0;
    }
    
    

    结果演示:
    在这里插入图片描述
    (完)

    展开全文
  • 拓扑排序(C语言实现)

    2019-03-24 02:05:45
    NULL 博文链接:https://touch-2011.iteye.com/blog/1075871
  • 拓扑排序C语言详解

    2020-03-28 15:24:19
    1. 拓扑排序是对有向无环图的操作。 2. 如果有环,则会出现,没有入度为0的点的情况,如图。任务之间相互等待。 3. 逐步输出入度为0的点,当入度为0的点有多个时,随意输出。 4. 建立一个栈的辅助空间,存放入度为0...

    1. 拓扑排序是对有向无环图的操作。
    2. 如果有环,则会出现,没有入度为0的点的情况,如图。任务之间相互等待。

    在这里插入图片描述

    3. 逐步输出入度为0的点,当入度为0的点有多个时,随意输出。
    4. 建立一个栈的辅助空间,存放入度为0的点,避免每次都需遍历寻找是否有入度为0的结点。
    5. 由第三点,显然拓扑排序结果不唯一。

    实现如图AOV网的拓扑排序

    在这里插入图片描述
    对应的邻接表
    在这里插入图片描述
    核心代码:

    //**************输出GL的拓扑排序序列**************
    int TopologicalSort(GraphAdjList GL)
    {
    	EdgeNode* p;
    	int i, k, gettop;
    	int top = 0;												//指向栈顶
    	char* stack;												//建栈存储入度为0的点
    	stack = (char*)malloc(GL->numVertexes * sizeof(char));			//建栈
    	if (stack == NULL)
    		exit(0);
    	for (i = 0; i < GL->numVertexes; i++)								//将入度为0的结点入栈
    		if (GL->adjList[i].in == 0)
    			stack[++top] = i;
    	while (top != 0)													//栈非空
    	{
    		gettop = stack[top--];											//出栈
    		printf("%c->", GL->adjList[gettop].data);					//打印此结点的值
    		for (p = GL->adjList[gettop].firstedge; p!=NULL; p = p->next)			//对此顶点的弧表遍历
    		{
    			k = p->adjvex;
    			if (!(--GL->adjList[k].in))									//对k号顶点邻接点的入度减一			
    				stack[++top] = k;										//	若减1后入度为0.则入栈
    		}
    	}
    	return 0;
    }
    

    所有代码如下,编译环境vc6.0

    /*
    先根据邻接表逻辑结构图生成对应的图
    再对图进行拓扑排序
    */
    #include <stdio.h>
    #include <stdlib.h>
    #define MAXVEX 100						//最大顶点数
    #define INFINITY 99999					//用99999表示无限大
    
    //***************************边表结点***************************
    typedef struct EdgeNode
    {
    	int adjvex;											//邻接点域,存储该结点对应的下标
    	//int weight;										//用于存储权值,非网图不需要
    	struct EdgeNode* next;								//指向下一个邻接结点
    }EdgeNode;
    
    //***************************顶点表结点***************************
    typedef struct VertexNode
    {
    	int in;												//顶点的入度个数
    	char  data;											//顶点域,存储顶点信息
    	EdgeNode* firstedge;								//边表头指针,指向第一个边表结点
    }VertexNode,AdjList[MAXVEX];
    
    //***************************邻接表结构***************************
    typedef struct
    {
    	AdjList adjList;									//顶点表结点数组
    	int numVertexes, numEdges;							//当前顶点个数和边数
    }graphAdjList, * GraphAdjList;
    
    //**************************无向图邻接表的创建*************************
    void CreateALGraph(GraphAdjList G)
    {
    	int i, j, k;
    	EdgeNode* e;
    	printf("输入顶点数和边数\n");
    	scanf("%d%d", &G->numVertexes, &G->numEdges);
    	getchar();														//获取缓冲区的 回车符
    
    	for (i = 0; i < G->numVertexes; i++)								//读入顶点信息,建立顶点表
    	{
    		printf("输入第%d个顶点值\n", i + 1);
    		scanf("%c", &G->adjList[i].data);							//输入顶点信息
    		getchar();													//获取缓冲区的 回车符
    		G->adjList[i].firstedge = NULL;								//将边表置为空表
    		G->adjList[i].in = 0;										//入度为0
    	}
    	for (k = 0; k < G->numEdges; k++)								//建立边表
    	{
    		printf("输入边(vi,vj)的下标:\n");
    		scanf("%d%d", &i, &j);
    		e = (EdgeNode*)malloc(sizeof(EdgeNode));				//向内存申请空间
    		if (e == NULL)
    		{
    			printf("内存申请失败\n");
    			exit(0);
    		}
    		G->adjList[j].in++;								//入度加一
    		e->adjvex = j;									//这三步,类似于单链表的头插法
    		e->next = G->adjList[i].firstedge;
    		G->adjList[i].firstedge = e;
    	}
    }
    
    //**************输出GL的拓扑排序序列**************
    int TopologicalSort(GraphAdjList GL)
    {
    	EdgeNode* p;
    	int i, k, gettop;
    	int top = 0;												//指向栈顶
    	char* stack;												//建栈存储入度为0的点
    	stack = (char*)malloc(GL->numVertexes * sizeof(char));			//建栈
    	if (stack == NULL)
    		exit(0);
    	for (i = 0; i < GL->numVertexes; i++)								//将入度为0的结点入栈
    		if (GL->adjList[i].in == 0)
    			stack[++top] = i;
    	while (top != 0)													//栈非空
    	{
    		gettop = stack[top--];											//出栈
    		printf("%c->", GL->adjList[gettop].data);					//打印此结点的值
    		for (p = GL->adjList[gettop].firstedge; p!=NULL; p = p->next)			//对此顶点的弧表遍历
    		{
    			k = p->adjvex;
    			if (!(--GL->adjList[k].in))									//对k号顶点邻接点的入度减一			
    				stack[++top] = k;										//	若减1后入度为0.则入栈
    		}
    	}
    	printf("\n");
    	return 0;
    }
    
    int main()
    {
    	graphAdjList GL;
    	CreateALGraph(&GL);
    	printf("拓扑排序结果如下:\n");
    	TopologicalSort(&GL);
    	return 0;
    }
    

    输出结果
    在这里插入图片描述

    展开全文
  • 拓扑排序C语言

    2019-11-27 09:39:24
    #include <stdio.h> #include <stdlib.h> #define n 6 #define SIZE 100 #define NEWSIZE 10 typedef struct arcnode { int weight; int yu; struct arcnode *next;...typedef struct node/...
    #include <stdio.h>
    #include <stdlib.h>
    #define n 6
    #define SIZE 100
    #define NEWSIZE 10
    typedef struct arcnode
    {
     int weight;
     int yu;
     struct arcnode *next;
    } arcnode;
    typedef struct node//头
    {
     int rudu;//统计一下入度
     char info;
     struct arcnode *firstnext;
    }node;
    typedef int ElemType;
    typedef struct
    {
     ElemType *top;
     ElemType *base;
     int size;
    }SqStack;
    //chu shi hua 
    int InitStack(SqStack &S)
    {
     S.base=(ElemType*)malloc(sizeof(ElemType)*SIZE);
     if(!S.base) return 0;
     S.top=S.base;
     S.size=SIZE;
     return 1;
    }
    int Push(SqStack &S,ElemType e)
    {
     if(S.top-S.base>=S.size)
     {
      S.base=(ElemType*)realloc(S.base,sizeof(ElemType)*(S.size+NEWSIZE));
      if(!S.base) return 0;
      S.top=S.base+S.size;
      S.size+=NEWSIZE;
     }
    // *S.top++=e;
     *S.top=e;
     ++S.top;
     return 1;
    }
    int Pop(SqStack &S,ElemType &e)
    {
     if(S.top==S.base) return 0;
     //e=*--S.top;
     --S.top;
     e=*S.top;
    }
    int isempty(SqStack &S)
    {
     if(S.top==S.base) return 1;
     return 0;
    }
    int m;
    void setTu(struct node Tu[])
    {
    int i,j,k,w;
     arcnode *p;
     printf("请输入是否有方向(0无 1有):");
     scanf("%d",&k);//0or1
     for(i=1;i<=n;i++)//初始化
     {
      Tu[i].rudu=0;//每个的入度的值为0
      Tu[i].firstnext=NULL;
     }
     printf("请输入边的集合:");
     scanf("%d%d%d",&i,&j,&w);//由i,->j, 权值
     while((i>=1)&&(i<=n)&&(j>=1)&&(j<=n))//当输入(0 0 0)跳出
     {
      p=Tu[i].firstnext;//把头的指向下一个的指针给p
      while(p!=NULL&&(p->yu!=j))//判断是否加过,防止重复
       p=p->next;
      if(p==NULL)
      {
       p=(arcnode*)malloc(sizeof(arcnode));
       p->yu=j;
       p->weight=w;
       p->next=Tu[i].firstnext;
       Tu[i].firstnext=p;
       ++(Tu[j].rudu);
      }
      if(k==0)
      {
       p=(arcnode*)malloc(sizeof(arcnode));
       p->yu=i;
       p->weight=w;
       p->next=Tu[j].firstnext;
       Tu[j].firstnext=p;
       ++(Tu[j].rudu);
      }
      printf("请输入i,j,w(若结束输入000)");
      scanf("%d%d%d",&i,&j,&w);
     }
    } 
    void tuopu(struct node Tu[])
    {
     SqStack S;
     InitStack(S);
     Tu[1].info='a';
     Tu[2].info='b';
     Tu[3].info='c';
     Tu[4].info='d';
     Tu[5].info='e';
     Tu[6].info='f';
     int i,count;
     for(i=1;i<=n;i++)
     {
      if(Tu[i].rudu==0)
       Push(S,i);
     }
     count=0;
     int e;
      while(!isempty(S))
     {
     Pop(S,e); printf("%c",Tu[e].info);
      count++;
      arcnode *q;
      q=Tu[e].firstnext;
      while(q!=NULL)
      {
       int c;
       c=q->yu;
       Tu[c].rudu--;
       if(Tu[c].rudu==0)
        Push(S,c);
       q=q->next;
      } 
     }
     if(count<n)
     {
      printf("%d",count);
      printf("error");
     }
    }
    void main()
    {
     struct node Tu[n+1];
     setTu(Tu);
     tuopu(Tu);
    }
    
    展开全文
  • C语言实现图的拓扑排序
  • 拓扑排序c语言课程设计论文《软件技术基础》课程设计PAGEPAGE 1中南民族大学计算机科学学院 专业 :自动化 学号:******* 姓名 :*******拓扑排序一 目的通过课程设计,加深对《程序设计语言》和《软件技术基础》课程...

    拓扑排序c语言课程设计论文

    《软件技术基础》课程设计

    PAGE

    PAGE 1

    中南民族大学计算机科学学院 专业 :自动化 学号:******* 姓名 :*******

    拓扑排序

    一 目的

    通过课程设计,加深对《程序设计语言》和《软件技术基础》课程所学知识的理解,熟练掌握和巩固C语言的基本知识和语法规范,包括:数据类型(整形、实型、字符型、指针、数组、结构等);运算类型(算术运算、逻辑运算、自增自减运算、赋值运算等);程序结构(顺序结构、判断选择结构、循环结构);库函数应用等;复杂任务功能分解方法(自顶向下逐步求精、模块化设计、信息隐藏等),熟练掌握和巩固三种基本图形结构的逻辑结构、存储结构以及相关运算和应用。

    学会编制结构清晰、风格良好、数据结构适当的C语言程序,从而具备利用计算机编程分析解决综合性实际问题的初步能力。

    二 需求分析

    题目描述:判断一个有向图是否存在回路,并求出有向无环图的拓扑序列。

    1、输入数据

    在工程文件中保存输入2个字符串数TXT文件。第一个为图按次序排列的所有边的前顶点,第二个为相对应的第二个顶点。

    2、输出数据

    图的定点数,边数,每个顶点的信息及入度,构造的邻接表,图的拓扑排序。

    3、程序功能

    已将AOV网存入文件中,运行时从文件读取数据;对一个AOV网,应判断其是否是有向无环图,若是则输出其任意一个拓扑排序序列,不是则进行相关的说明;构造图的邻接表;输出所有顶点的入度。

    三 概要设计

    1、全局变量或类型说明

    //********结构体定义***********//

    typedef struct A_Node //定义表结点结构

    {

    int adjvex; //与vi相邻接的顶点编号

    struct A_Node *nextarc; //指向下一条弧(边)的指针

    } A_Node;

    typedef struct V_Node //定义表头结点结构

    {

    int data;

    A_Node *firstarc; //指向第一条弧(边)的指针

    } V_Node, AdjList[MAX_NUM];

    typedef struct //定义邻接表结构

    {

    AdjList vertices; //表头结点数组

    int vex_num, arc_num; //顶点和弧(边)的个数

    } ALGraph;

    typedef struct //构件栈

    {

    Elem_T *base;

    Elem_T *top;

    int stacksize;

    } Sq;

    2、模块功能

    1) void Init(Sq *S);

    功能:初始化栈。构造一个空栈S

    参数:*S 待初始化的栈

    2) int Stack(Sq *S)

    功能:判断空栈

    参数:S 待判断的栈

    返回值:栈为空返回 1;栈非空返回 0

    3) Void Int(Sq *S, Elem_T e)

    功能:元素入栈

    参数:*S 待操作的栈;插入元素e为新的栈顶元素

    4) void Out(Sq *S, Elem_T e);

    功能:元素出栈

    参数:*S 待操作的栈;若栈不空,则删除S的栈顶元素,用e返回其值,并返回1;否则返回0

    5) void Creat_Graph(ALGraph *G)

    功能:建立图。函数内包含了由用户输入顶点数、弧数、顶点以及弧的操作

    参数:*G 待操作的图

    返回值:图建立成功返回1;图建立失败返回0

    6) void Find_InDegree(ALGraph G, int indegree[])

    功能:求顶点的入度

    参数:G 待操作的图,indegree[]储存每个顶点的入度的数组

    7) void TuoPu(ALGraph G);

    功能:实现拓扑排序,并在图形界面上演示排序过程

    参数:G 待进行拓扑排序的图

    错误判断:包含有向图是否有环的判断

    四 详细设计

    源代码详情如下:

    //*****拓扑排序*********//

    //******张雪涛*********//

    //*****2013.12.27******//

    //*****函数头文件、宏定义、变量声明*******//

    #include

    #include

    #define MAX_NUM 15

    #define STACK_SIZE 100

    #define STACK_MENT 10

    #define OK 1

    #define M 20

    #define ERROR 0

    #define NUM 15

    typedef int Elem_T;

    char number1[NUM];

    char number2[NUM];

    //********结构体定义****

    展开全文
  • 拓扑排序(C语言简单实现)

    千次阅读 2020-11-19 17:40:53
    拓扑排序 本文参考自《大话数据结构》 AOV定义 在一个表示工程的有向图中,用顶点表示活动,用弧表示活动之间的优先关系,这样的有向图为顶点表示活动的网,我们称为AOV网(Activity On Vertex Network)。AOV网中...
  • 拓扑排序 C语言代码

    2021-05-25 01:59:43
    } /////////拓扑排序算法 int TopologicalSort(ALGraph G) { //有向图采用邻接表存储结构 //若G无回路,则flag=0,输出G的顶点的一个拓扑序列,否则给出该有向图有回路的提示. int i,count,k; int *indegree=(int *)...
  • 拓扑排序~C语言完整代码

    千次阅读 多人点赞 2019-05-01 22:15:09
    对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序,是将G中所有顶点排成一个线性序列,使得图中任意一对顶点u和v,若边(u,v)∈E(G),则u在线性序列中出现在v之前。通常,这样的线性序列称为满足拓扑...
  • 功能模块:拓扑排序 适用领域:有向图 基础模块:Graph Queue */ #include<stdlib.h> #include<stdio.h> #define MAXSIZE 50 typedef char VertexType; typedef struct EdgeNode {
  • C语言实现拓扑排序

    2020-06-17 00:21:36
    顶点表示活动、边表示活动间先后关系的有向图称做顶点活动网...拓扑排序实现思路:先把入度为0的结点全部压入栈中,遍历入度为0的结点,把遍历过的结点压入栈中,然后删除以该结点为弧尾的弧和删除该结点。 ...
  • 和以往一样,本文会先对拓扑排序的理论知识进行介绍,然后给出C语言的实现。后续再分别给出C++和Java版本的实现。拓扑排序介绍拓扑排序(Topological Order)是指,将一个有向无环图(Directed Acyclic Graph简称DAG)...
  • 解题思路:注意事项:样例可以通过参考代码:#include#includeusingnamespacestd;#defineERROR-1#defineOK1#defineMAX51intcount;intTopoloicalSort(inta[MAX][MAX],intn){stacks;intindegree[n]={0};...
  • 算法步骤: (1)根据邻接矩阵统计每个顶点的入度,统计结果存在mark[]中; (2)在mark[]中寻找为0的顶点i,找到后将mark[i]–,并且... printf("拓扑排序为:"); while(number) Delete(); return 0; } 运行结果:
  • 拓扑排序(完整案列及C语言完整代码实现)

    千次阅读 多人点赞 2020-08-15 11:49:11
    写在前面:博主是一位普普通通的19届二本大学生,平时最大的爱好就是听听歌,逛逛B站。博主很喜欢的一句话花开堪折直须折,莫待无花空折枝:博主的理解是头一次为人,就应该做自己想做的事,做自己...拓扑排序的方法 .
  • 拓扑排序简单实现(C语言)

    千次阅读 2021-04-28 20:04:58
    拓扑排序简单实现(C语言拓扑排序预备知识执行步骤图解代码实现 今天刷洛谷的图时看到好多题都要用图的拓扑排序,索性就学一把,敲一敲代码学学算法也复习一下图的具体操作和栈的使用。 拓扑排序 对一个有向无环图...
  • 拓扑排序C语言实现)

    万次阅读 多人点赞 2016-12-14 17:31:04
    图文并茂,超详细的拓扑排序。包含C语言实现和超详细的注释
  • 例子 算法
  • C语言拓扑排序C语言

    2021-11-22 19:01:04
    } } void Print(int n ,char data){ cout 拓扑排序取出的点为:"; } void FindInDegree(ALGraph G,int indegree[]) { int i,k; ArcNode *p; for(i=0;i;i++) indegree[i]=0; for(i=0;i;i++) { p=G.vertexs...
  • main.cpp #include<stdio.h> #include<stdlib.h> #include"Queue.h" ... printf("拓扑排序是有向图\n"); LGraph Graph; Graph = BuildGraph(); TopSort(Graph); } Queue.h #ifndef QUEUE #incl...
  • 拓扑排序c语言实现

    千次阅读 2016-11-12 10:39:48
    拓扑排序c语言实现 标签: 语言matrixcini百度 2012-08-01 22:46 4703人阅读 评论(1) 收藏 举报  分类: 数据结构(8)  版权声明:本文为博主原创文章,转载请注明出处...
  • 算法思想 计算每个节点的入度,每轮输出入度为零的节点,并且将已经输出的节点从图中删除。即,将该节点指向的节点入度减一; 在实现上,维护一个入度数组,保存每个节点的入度,每一轮将入度为零的节点入栈(这里用...
  • 算法导论:P330#include #include #include #include #define white 0#define gray 1#define black 2#define NIL -1using namespace std;typedef struct node{int w;int to;int next;}node;const int MAX = 1000;...
  • 拓扑排序: 用于排列事件发生的顺序,也可判断图中是否有环。 代码实现: #include<stdio.h> #include<stdlib.h> #define MaxVexNum 50 #define MaxInt 32767 #define MaxEdgeNum 50 //邻接矩阵 ...
  • /*拓扑排序*/ #include<stdio.h> #include<stdlib.h> #define max 105 typedef struct edge{ int adjvex; int weight; struct edge* next; }Elink; typedef struct ver{ int vertex; Elink* ...
  • 拓扑 排序 C语言 算法

    2010-06-27 11:51:41
    拓扑 排序 C语言 算法 拓扑 排序 C语言 算法 绝对可以 欢迎下载
  • 拓扑排序C语言代码

    2021-05-25 08:21:18
    #include#include#include#include//----------------公共的-----------------#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2//-----------------------------...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,969
精华内容 1,587
关键字:

拓扑排序c语言

c语言 订阅