【数据结构与算法】使用邻接表实现AOV网的拓扑排序算法（头歌）

任务描述

本关任务：用邻接表存储有向图，在顶点表中增加入度域，使用队列存储入度为零的顶点编号，实现AOV网的拓扑排序算法，并输出拓扑序列，顶点个数少于20个。

编程要求

根据提示，在右侧编辑器补充代码。

测试说明

输入描述：

首先输入图中顶点个数和边的条数； 输入顶点的信息（字符型）； 输入各顶点的入度； 输入各边及其权值。

输出描述：

输出 AOV 网的拓扑序列（顶点信息），以空格隔开，最后一个顶点后面有空格，如果AOV网存在回路，输出"有回路"的信息，占一行。

输入样例1：

1. 6 9
2. A B C D E F
3. 3 0 1 3 0 2
4. 1 0
5. 1 3
6. 2 0
7. 2 3
8. 3 0
9. 3 5
10. 4 2
11. 4 3
12. 4 5

输出样例1：

B E C D F A

输入样例2：

1. 6 8
2. A B C D E F
3. 0 0 1 3 2 2
4. 0 2
5. 0 3
6. 1 3
7. 1 5
8. 2 4
9. 3 4
10. 4 5
11. 5 3

输出样例2：

有回路

#include <stdio.h>
#include <stdlib.h>
// 定义弧节点
struct Arcnode
{
    int adjvex;             // 弧的终点顶点下标
    struct Arcnode *next;   // 指向下一个弧节点的指针
};
// 定义顶点节点
struct Vertexnode
{
    int in;                 // 顶点的入度
    char vertex;            // 顶点的值
    struct Arcnode *firstedge;  // 指向第一个弧节点的指针
};
#define Maxsize 20
// 定义邻接表图结构
typedef struct
{
    struct Vertexnode adjlist[Maxsize]; // 顶点数组
    int vertexnum;                      // 顶点数量
    int arcnum;                         // 弧数量
} ALgraph;
// 初始化邻接表图结构
void ALgraph_init(ALgraph *G, char a[], int n, int e)
{
	//write your code
    //=======begin=======
    G->vertexnum = n; G->arcnum = e;
    int i, j;
    struct Arcnode *s, *r;
    
    for (int i=0; i<n; i++)
    {
    	G->adjlist[i].vertex = a[i];
    	G->adjlist[i].firstedge = NULL;
    	scanf("%d ", &G->adjlist[i].in);
	}
	
	for (int k=0; k<e; k++)
	{
		scanf("%d %d", &i, &j);
		
		s = (struct Arcnode*)malloc(sizeof(struct Arcnode));
		s->adjvex = j; 
		s->next = G->adjlist[i].firstedge;
		G->adjlist[i].firstedge = s;
	}
    //========end========
}
// 销毁邻接表图结构
void ALgraph_destroy(ALgraph *G)
{
    int i;
    struct Arcnode *p;
    for (i = 0; i < G->vertexnum; i++)
    {
        p = G->adjlist[i].firstedge;
        while (p)
        {
            struct Arcnode *q = p;
            p = p->next;
            free(q);
        }
    }
}
// 拓扑排序
void ALgraph_TopSort(ALgraph *G)
{
	//write your code
    //=======begin=======
    int front = -1, rear = -1, count = 0, x, k, q[Maxsize], len = 0;
    char s[Maxsize];
    struct Arcnode *p;
    
    for (int i=0; i<G->vertexnum; i++)
    {
    	if (G->adjlist[i].in == 0)
    	{
    		q[++rear] = i;
		}
	}
	
	while (front != rear)
	{
		x = q[++front];
		s[len++] = G->adjlist[x].vertex;
		count++;
		p = G->adjlist[x].firstedge;
		
		while (p)
		{
			k = p->adjvex;
			G->adjlist[k].in--;
			
			if (G->adjlist[k].in == 0)
			{
				q[++rear] = k;
			}
			
			p = p->next;
		}
	}

	if (count < G->vertexnum)
	{
		printf("有回路");
	}
	else
	{
		for (int i=0; i<len; i++)
		{
			printf("%c ", s[i]);
		}
	}
    //========end========
}
int main()
{
    int i, n, m;
    scanf("%d%d", &n, &m);
    // 动态申请字符数组
    char *b = (char *)malloc(sizeof(char) * n);
    for (i = 0; i < n; i++)
    {
        scanf(" %c", &b[i]);
    }
    ALgraph al;
    ALgraph_init(&al, b, n, m);
    ALgraph_TopSort(&al);
    ALgraph_destroy(&al);
    // 释放内存
    free(b);
    return 0;
}