图—拓扑排序_即使有向无环图的拓扑序列唯一,也不能唯一确定该图csdn-CSDN博客

本文链接：https://blog.csdn.net/thdwx/article/details/127414183

拓扑排序是对有向无圈图的顶点的一种排序，它使得如果存在一条从 $v_{i}$ 到 $v_{j}$ 的路径，那么在排序中 $v_{j}$ 一定在 $v_{i}$ 后面。显然，如果图含有圈，那么拓扑排序是不可能的，因为如果存在 $v,w,v$ 的圈，那么 $v$ 在 $w$ 之前， $w$ 也在 $v$ 之前，这与拓扑排序是矛盾的。此外，拓扑排序的结果不一定是唯一的，任何合理的排序都是可以的。

以下图为例：

一个简单的求拓扑排序的算法是先找到任意一个入度为0的顶点（度指连接顶点的边数，入度是进入顶点的边数），然后我们对该顶点编号，再将它和它的边从图中删除。然后，对图的其余部分做同样的处理。代码如下：

int FindNewZeroIndegreeV(g* p) {
	for (int i = 0; i < 7; i++) {
		if (p->arr[i]->indegree == 0 && p->arr[i]->visited == 0)
			return i;
	}
	return -1;
}

void topsort(g* p) {
	int count;
	for (count = 0; count < 7; count++) {
		int v = FindNewZeroIndegreeV(p);//返回入度为0且没有被访问过的顶点
		if (v == -1) {
			printf("图中有圈\n");
			break;
		}
		p->arr[v]->order = count + 1;//给该顶点编号
		p->arr[v]->visited = 1;//标记为已访问
		l* tmp = p->arr[v]->next;
		while (tmp != NULL) {//与该节点邻接的节点入度全部-1，表示该节点以及该节点的边被删除
			p->arr[tmp->val]->indegree--;
			tmp = tmp->next;
		}
	}
}

由于每次寻找入度为0的未访问元素都需要花费 $O(|V|)$ 时间，不难得到这个算法总的花费时间为 $O(|V|^2)$ ，当节点数量过多时，这个算法的性能就会越来越差，并且在查找未访问入度为0元素时，已被访问过的元素实际上不用再进行考察了，新的入度为零的元素也一定只会在更新邻接顶点入度时产生（最开始图中入度为0的顶点只有一个，因为如果有两个入度为零的顶点，那么不论从它们之中的哪个出发，都遍历不到另一个，所以即使有两个或以上入度为零的顶点，它们的拓扑排序也是独立的），所以实际上只需要在很小的范围内找入度为0的顶点，而这个算法执行了大量没有意义的操作，所以性能也会变差。

根据上述分析，我们可以使用一个队列来存放初始入度为0的元素，当队列不为空时，则令队头元素出队，并对其邻接元素进行修改，只要邻接顶点入度降为0就入队（这里不需要邻接顶点未被访问，因为如果邻接顶点被访问过，就形成了一个圈），重复此操作直到队列为空。代码如下：

void topsort(g* p) {
	int count = 1;
	q* pq = CreatQueue();//创建队列
	enqueue(pq, 0);//入队
	while (!isempty(pq)) {
		int v = dequeue(pq);
		p->arr[v]->order = count++;
		l* tmp = p->arr[v]->next;
		while (tmp != NULL) {
			p->arr[tmp->val]->indegree--;
			if (p->arr[tmp->val]->indegree == 0) {
				enqueue(pq, tmp->val);
			}
			tmp = tmp->next;
		}
	}
}

显然，此算法将所有的节点和边都遍历了一遍，所以它的时间复杂度为 $O(|E|+|V|)$ 。

图的建立及测试代码：

typedef struct list {//邻接表，存放邻接顶点的编号
	int val;
	struct list* next;
}l;

typedef struct table {
	int visited;//表示顶点是否访问过
	int indegree;//顶点入度
	int order;//顶点的拓扑编号
	l* next;//指向邻接表的指针
}t;

typedef struct graph {//图中存放指向各个顶点信息的指针
	t* arr[7];
}g;

g* CreatGraph() {
	g* p = (g*)malloc(sizeof(g));
	for (int i = 0; i < 7; i++) {
		t* pt = (t*)malloc(sizeof(t));
		pt->next = NULL;
		pt->visited = 0;
		p->arr[i] = pt;
	}

	l* tmp = (l*)malloc(sizeof(l));
	p->arr[0]->indegree = 0;
	tmp->val = 1;
	tmp->next = p->arr[0]->next;
	p->arr[0]->next = tmp;
	tmp = (l*)malloc(sizeof(l));
	tmp->val = 2;
	tmp->next = p->arr[0]->next;
	p->arr[0]->next = tmp;
	tmp = (l*)malloc(sizeof(l));
	tmp->val = 3;
	tmp->next = p->arr[0]->next;
	p->arr[0]->next = tmp;

	p->arr[1]->indegree = 1;
	tmp = (l*)malloc(sizeof(l));
	tmp->val = 3;
	tmp->next = p->arr[1]->next;
	p->arr[1]->next = tmp; 
	tmp = (l*)malloc(sizeof(l));
	tmp->val = 4;
	tmp->next = p->arr[1]->next;
	p->arr[1]->next = tmp;

	p->arr[2]->indegree = 2;
	tmp = (l*)malloc(sizeof(l));
	tmp->val = 5;
	tmp->next = p->arr[2]->next;
	p->arr[2]->next = tmp;

	p->arr[3]->indegree = 3;
	tmp = (l*)malloc(sizeof(l));
	tmp->val = 2;
	tmp->next = p->arr[3]->next;
	p->arr[3]->next = tmp;
	tmp = (l*)malloc(sizeof(l));
	tmp->val = 5;
	tmp->next = p->arr[3]->next;
	p->arr[3]->next = tmp;
	tmp = (l*)malloc(sizeof(l));
	tmp->val = 6;
	tmp->next = p->arr[3]->next;
	p->arr[3]->next = tmp;

	p->arr[4]->indegree = 1;
	tmp = (l*)malloc(sizeof(l));
	tmp->val = 6;
	tmp->next = p->arr[4]->next;
	p->arr[4]->next = tmp;
	tmp = (l*)malloc(sizeof(l));
	tmp->val = 3;
	tmp->next = p->arr[4]->next;
	p->arr[4]->next = tmp;

	p->arr[5]->indegree = 3;

	p->arr[6]->indegree = 2;
	tmp = (l*)malloc(sizeof(l));
	tmp->val = 5;
	tmp->next = p->arr[6]->next;
	p->arr[6]->next = tmp;

	return p;
}

//队列
typedef struct queue {
	int arr[50];
	int front;
	int rear;
	int num;
}q;

q* CreatQueue() {
	q* p = (q*)malloc(sizeof(q));
	p->front = 0;
	p->rear = -1;
	p->num = 0;
	return p;
}

void enqueue(q* p, int x) {
	p->num++;
	p->arr[++p->rear] = x;
}

int dequeue(q* p) {
	p->num--;
	return p->arr[p->front++];
}

int isempty(q* p) {
	return p->num == 0;
}

//测试代码
void print(g* p) {
	for (int i = 0; i < 7; i++) {
		printf("v%d    ----->    %d\n", i + 1, p->arr[i]->order);
	}
}

int main() {
	g* p = CreatGraph();

	topsort(p);

	print(p);

	return 0;
}