实现有向无环图的拓扑排序

题目

用DFS和BFS实现如下有向无环图的拓扑排序：

解题思路

采用multimap存储这幅图，依次建立每个节点和它对应的后序节点组成的数组的映射。

代码如下：

Graph.h

#pragma once
#include<iostream>
#include<vector>
#include<map>
#include<queue>
#include<list>
using namespace std;
class Graph
{
public:
	void Create();
	void Print();
	void Bread_sort();
	void Print_topo();
	void DFS();
	void Print_list();
private:
	multimap<int, vector<int>> m;
	queue<int> topo;
	void recursive_depth_sort(int v);
	bool visited[10];
	list<int> l;
};

Graph.cpp

#include "Graph.h"
void Graph::Create()
{
	vector<int> v0, v1, v2, v3, v4, v5, v6, v7, v8, v9;
	v0.push_back(1); v0.push_back(5);
	v1.push_back(7);
	v3.push_back(2); v3.push_back(4); v3.push_back(7); v3.push_back(8);
	v4.push_back(8);
	v6.push_back(0); v6.push_back(1); v6.push_back(2);
	v8.push_back(2); v8.push_back(7);
	v9.push_back(4);
	m.insert(pair<int, vector<int>>(0, v0));
	m.insert(pair<int, vector<int>>(1, v1));
	m.insert(pair<int, vector<int>>(2, v2));
	m.insert(pair<int, vector<int>>(3, v3));
	m.insert(pair<int, vector<int>>(4, v4));
	m.insert(pair<int, vector<int>>(5, v5));
	m.insert(pair<int, vector<int>>(6, v6));
	m.insert(pair<int, vector<int>>(7, v7));
	m.insert(pair<int, vector<int>>(8, v8));
	m.insert(pair<int, vector<int>>(9, v9));
}
void Graph::Print()
{
	for (int i = 0; i < 10; i++)
	{
		cout << i << " ";
		multimap<int, vector<int>>::iterator p = m.find(i);
		for (int j = 0; j < (*p).second.size(); j++)
		{
			cout << (*p).second[j];
		}
		cout << endl;
	}
}
void Graph::Bread_sort()
{
	int predecessor_count[10] = { 0 };
	for (int i = 0; i < 10; i++)
	{
		multimap<int, vector<int>>::iterator p = m.find(i);
		for (int j = 0; j < (*p).second.size(); j++)
			predecessor_count[(*p).second[j]]++;
	}
	queue<int> ready_to_process;
	multimap<int, vector<int>>::iterator p;
	int j;
	for (int i = 0; i < 10; i++)
	{
		if (predecessor_count[i] == 0)
			ready_to_process.push(i);
	}
	while (!ready_to_process.empty())
	{
		int v = ready_to_process.front();
		topo.push(v);
		p = m.find(v);
		for (j = 0; j < (*p).second.size(); j++)
		{
			int m = (*p).second[j];
			predecessor_count[m]--;
			if (predecessor_count[m] == 0)
				ready_to_process.push(m);
		}
		ready_to_process.pop();
	}
}
void Graph::Print_topo()
{
	while (!topo.empty())
	{
		cout << topo.front();
		topo.pop();
	}
}
void Graph::recursive_depth_sort(int v)
{
	visited[v] = true;
	multimap<int, vector<int>>::iterator p = m.find(v);
	int degree = (*p).second.size();
	for (int i = 0; i < degree; i++) {
		int w = (*p).second[i];
		if (!visited[w]) // Order the successors of w.
			recursive_depth_sort(w);
	}
	list<int>::iterator q = l.begin(); // Put v into topological_order.
	l.insert(q, v);
}
void Graph::DFS()
{
	for (int v = 0; v < 10; v++)
		visited[v] = false;
	for (int v = 0; v < 10; v++)
	{
		if (!visited[v]) // Add v and its successors into topological order.
			recursive_depth_sort(v);
	}
}
void Graph::Print_list()
{
	list<int>::iterator p;
	for (p = l.begin(); p != l.end(); ++p)
	{
		cout << *p << endl;
	}
}

main.cpp

#include"Graph.h"
int main()
{
	Graph g;
	g.Create();
	g.Print();
	g.Bread_sort();
	g.Print_topo();
	g.DFS();
	g.Print_list();
	return 0;
}