严蔚敏数据结构输出拓扑序列

#include <stdio.h>
#include <string.h>
#define OK 1
#define INFINITY 32767
#define MAX_VERTEX_NUM 30
#define MAXINFOLEN 30
#define ERROR 0
#define OVERFLOW -1
#define MAXVERTEXLEN 30
#define FALSE 0
#define TRUE 1
typedef int Status;
typedef enum { DG, DN, UDG, UDN }GraphKind;
typedef int VRType;
typedef int InfoType;
typedef char* VertexType;
//邻接表存储图结构
typedef struct ArcNode
{
	struct ArcNode* nextarc;
	InfoType* info;
	int adjvex;
}ArcNode;
typedef struct VNode
{
	VertexType data;
	ArcNode* firstnode;
}VNode, AdjList[MAX_VERTEX_NUM];
typedef struct
{
	AdjList vertices;
	int vexnum, arcnum;
	GraphKind kind;
}ALGraph;
void CreatGraph_AL(ALGraph* G)
{
	printf("请输入邻接表存储图的种类，且只能存储有向图（0）与无向图（2）\n");
	scanf("%d", &(G->kind));
	int info;
	printf("请依次输入图的节点数，弧数，是否需要弧的信息\n");
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	for (int i = 0; i < G->vexnum; i++)
	{
		printf("请输入图的第%d个节点的描述\n", i + 1);
		G->vertices[i].data = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vertices[i].data) exit(OVERFLOW);
		gets(G->vertices[i].data);
		G->vertices[i].firstnode = NULL;
	}
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	if (G->kind == DG)
	{
		int tail, head;
		for (int i = 0; i < G->arcnum; i++)
		{
			printf("请输入第%d个节点关系\n", i + 1);
			printf("请输入弧尾描述信息\n");
			gets(ch);
			for (int j = 0; j < G->vexnum; j++)
			{
				if (strcmp(G->vertices[j].data, ch) == 0)
				{
					tail = j;
					break;
				}
			}
			printf("请输入弧头描述信息\n");
			gets(ch);
			for (int j = 0; j < G->vexnum; j++)
			{
				if (strcmp(G->vertices[j].data, ch) == 0)
				{
					head = j;
					break;
				}
			}
			ArcNode* p = (ArcNode*)malloc(sizeof(ArcNode));
			if (!p) exit(OVERFLOW);
			p->adjvex = head;
			ArcNode* s = G->vertices[tail].firstnode;
			if (!s)
			{
				p->nextarc = G->vertices[tail].firstnode;
				G->vertices[tail].firstnode = p;
			}
			else
			{
				while (s->nextarc)
					s = s->nextarc;
				p->nextarc = s->nextarc;
				s->nextarc = p;
			}
			if (info)
			{
				printf("请输入弧的描述信息\n");
				p->info = (int*)malloc(sizeof(int));
				if (!p->info) exit(OVERFLOW);
				scanf("%d", p->info);
				getchar();
			}
		}
	}
	else
	{
		int vex1, vex2;
		for (int i = 0; i < G->arcnum; i++)
		{
			printf("请输入第%d个节点关系\n", i + 1);
			printf("请输入第一个相关节点描述信息\n");
			gets(ch);
			for (int j = 0; j < G->vexnum; j++)
			{
				if (strcmp(G->vertices[j].data, ch) == 0)
				{
					vex1 = j;
					break;
				}
			}
			printf("请输入第二个相关节点描述信息\n");
			gets(ch);
			for (int j = 0; j < G->vexnum; j++)
			{
				if (strcmp(G->vertices[j].data, ch) == 0)
				{
					vex2 = j;
					break;
				}
			}
			ArcNode* p = (ArcNode*)malloc(sizeof(ArcNode));
			if (!p) exit(OVERFLOW);
			p->adjvex = vex1;
			ArcNode* s = G->vertices[vex2].firstnode;
			if (!s)
			{
				p->nextarc = G->vertices[vex2].firstnode;
				G->vertices[vex2].firstnode = p;
			}
			else
			{
				while (s->nextarc)
					s = s->nextarc;
				p->nextarc = s->nextarc;
				s->nextarc = p;
			}
			if (info)
			{
				printf("请输入弧的描述信息\n");
				p->info = (int*)malloc(sizeof(int));
				if (!p->info) exit(OVERFLOW);
				scanf("%d", p->info);
				getchar();
			}
			ArcNode* q = (ArcNode*)malloc(sizeof(ArcNode));
			if (!q) exit(OVERFLOW);
			q->adjvex = vex2;
			s = G->vertices[vex1].firstnode;
			if (!s)
			{
				q->nextarc = G->vertices[vex1].firstnode;
				G->vertices[vex1].firstnode = q;
			}
			else
			{
				while (s->nextarc)
					s = s->nextarc;
				q->nextarc = s->nextarc;
				s->nextarc = q;
			}
			if (info)
			{
				printf("请输入弧的描述信息\n");
				p->info = (int*)malloc(sizeof(int) * MAXINFOLEN);
				if (!p->info) exit(OVERFLOW);
				scanf("%d", p->info);
				getchar();
			}
		}
	}
}
//栈的数据结构及函数
#define STACK_INIT_SIZE 100
#define STACK_INCREASMENT 10
typedef int SElemType;
typedef struct
{
	SElemType* base, * top;
	int stacksize;
}SqStack;
Status InitStack(SqStack* S)
{
	S->base = (SElemType*)malloc(sizeof(SElemType) * STACK_INIT_SIZE);
	if (!S->base) exit(OVERFLOW);
	S->top = S->base;
	S->stacksize = STACK_INIT_SIZE;
}
Status Push(SqStack* S, SElemType e)
{
	if (S->top - S->base > S->stacksize)
	{
		S->base = (SElemType*)realloc(S->base, sizeof(SElemType) * (S->stacksize + STACK_INCREASMENT));
		if (!S->base) exit(OVERFLOW);
		S->stacksize += STACK_INCREASMENT;
	}
	*(S->top) = e;
	S->top++;
	return OK;
}
Status Pop(SqStack* S, SElemType* e)
{
	if (S->base == S->top)
		return ERROR;
	S->top--;
	*e = *(S->top);
	return OK;
}
Status StackEmpty(SqStack S)
{
	if (S.base == S.top)
		return TRUE;
	else
		return FALSE;
}
//拓扑序列输出
Status TopoLogicalSort(ALGraph G)
{
	int* indegree;
	indegree = (int*)malloc(sizeof(int) * G.vexnum);
	if (!indegree) exit(OVERFLOW);
	for (int i = 0; i < G.vexnum; i++)
		indegree[i] = 0;
	for (int i = 0; i < G.vexnum; i++)
	{
		ArcNode* p = G.vertices[i].firstnode;
		while (p)
		{
			indegree[p->adjvex]++;
			p = p->nextarc;
		}
	}
	SqStack S;
	InitStack(&S);
	for (int i = 0; i < G.vexnum; i++)
		if (indegree[i] == 0)
			Push(&S, i);
	int count = 0;
	while (!StackEmpty(S))
	{
		int i;
		Pop(&S, &i);
		count++;
		printf("-------%s-------\n", G.vertices[i].data);
		ArcNode* p = G.vertices[i].firstnode;
		while (p)
		{
			indegree[p->adjvex]--;
			if (indegree[p->adjvex] == 0)
				Push(&S, p->adjvex);
			p = p->nextarc;
		}
	}
	if (count == G.vexnum)
		return OK;
	else
		return ERROR;
}

//输出拓扑序列
int main()
{
	ALGraph G;
	CreatGraph_AL(&G);
	TopoLogicalSort(G);
	return 0;
}

原图：

 输入：

0
6 8 0
V1
V2
V3
V4
V5
V6
V1
V2
V1
V3
V1
V4
V3
V2
V3
V5
V4
V5
V6
V4
V6
V5

结果：