图-拓扑排序

1、拓扑排序

在一个表示工程的有向图中，有顶点表示活动，用弧表示活动之间的优先关系，这样的有向图为顶点表示活动的网，我们称为AOV网。

AOV网中的弧表示活动之间存在的某种制约关系。

所谓拓扑排序，其实就是对一个有向图构造拓扑序列的过程。

2、拓扑排序算法

对AOV网进行拓扑排序的基本思路：

从AOV网中选择一个入度为0的顶点输出；

然后删除此顶点，并删除以次顶点为尾的弧；

继续重复此操作.....

直到输出全部顶点或AOV网中不存在入度为0的顶点为止。

由于拓扑排序过程中，需要删除顶点，显然用邻接表更加方便。

因此我们需要为AOV网建立一个邻接表。

另外，考虑到算法过程中始终需要查找入度为0的顶点？

需要在原顶点表节点结构中，增加一个入度域in，in就是入度数字。

所以结构如下图：

第一幅图AOV网如下：

第二幅图的邻接表逻辑结构：

第三幅图邻接表数据结构：

3、算法及其详解

（1）算法如下图所示：

（2）详解如下：

7. 其它的处理方式类似，直至全部打印删除。

8. 最终的拓扑排序打印结果为：

当然，从整个过程来分析，这个结果并不是唯一的一种拓扑排序方案。

分析整个算法，对一个具有n各顶点e条弧的AOV网来说：

第8-10行扫描顶点表，将入度为0的顶点入栈的时间复杂度为O(n)；

而之后的while循环中，每个顶点进一次栈，出一次栈，入度减1的操作执行了e次。

所以整个算法的时间复杂度为O(n+e)。

4、本示例代码实现

#include <iostream>
#include <stack>
#include <malloc.h>
using namespace std;

#define  MAXVEX   6
#define  MAXEDGE  6

typedef struct EdgeNode
{
	int adjvex; // 邻接点域，存储该顶点对应的下标
	EdgeNode* next; //链域
}EdgeNode;

typedef struct VertexNode
{
	int inNum;                 //顶点入度索引值
	int data;                  //顶点值
	EdgeNode* firstEdge;       //边头指针
}VertexNode, AdjList[MAXVEX];

typedef struct  
{
	AdjList adjList;   //存储图中顶点容器
	int numVertexes;   //存储顶点数量
	int numEdges;      //存储边数量
}GraphAdjList;

//构建节点
void CreatEdgeNode(EdgeNode** pEdgeNode)
{
	*pEdgeNode = (EdgeNode*)malloc(sizeof(EdgeNode));
	//EdgeNode* edgeNode = *pEdgeNode;
	(*pEdgeNode)->adjvex = -1;
	(*pEdgeNode)->next = NULL;

}

//初始化图
void InitGraph(GraphAdjList* graphList)
{
	for (int i = 0; i < MAXVEX; i++)
		graphList->adjList[i].firstEdge = NULL;
}

//构建图
void CreatGraph(GraphAdjList* graphList)
{
	int i = 0, begin = 0, end = 0;
	EdgeNode* pEdgeNode = NULL;
	
	cout << "输入" << MAXVEX << "个顶点信息（顶点 入度）:" << endl;
	for (i = 0; i < MAXVEX; ++i)
	    {
		   graphList->adjList[i].data += 10;
		   cin >> graphList->adjList[i].data>> graphList->adjList[i].inNum;
	    }
	cout << "输入" << MAXEDGE << "条边的信息：" << endl;

	for (i = 0; i < MAXEDGE; ++i)
	{
	    cin >> begin >> end;
		CreatEdgeNode(&pEdgeNode);
		pEdgeNode->adjvex = end;
		pEdgeNode->next = graphList->adjList[begin].firstEdge;
		graphList->adjList[begin].firstEdge = pEdgeNode;
	}
}

// 打印输入信息的逻辑图
void PrintGraph(GraphAdjList* graphList)
{
	cout << "打印邻接表的逻辑图：" << endl;
	for (int i = 0; i < MAXVEX; ++i)
	{
		cout <<i<< " " << graphList->adjList[i].inNum << " " << graphList->adjList[i].data << " ";
		EdgeNode* p = graphList->adjList[i].firstEdge;
		cout << ": ";
		while (p != NULL)
		{
			int index = p->adjvex;
			cout << graphList->adjList[index].data << "  ";
			p = p->next;
		}
		cout << endl;
	}
}

//拓扑排序
bool TopologicalSort(GraphAdjList* graphList)
{
	EdgeNode* pEdgeNode = NULL;
	int i = 0, k = 0, getTop = 0;
	int nCnt = 0;
	std::stack<int>mStack;
	for (i = 0; i < MAXVEX; ++i)
	{
		if (graphList->adjList[i].inNum == 0)
			mStack.push(i);
	}
	while (!mStack.empty())
	{
		getTop= mStack.top();
		mStack.pop();
		nCnt++;
		if (MAXVEX == nCnt)
		{//去掉拓扑路径后面-->
			cout << graphList->adjList[getTop].data;
			 break;
		}

		cout << graphList->adjList[getTop].data << "-->";
		pEdgeNode = graphList->adjList[getTop].firstEdge;
		while (pEdgeNode != NULL)
		{
			k = pEdgeNode->adjvex;
			--graphList->adjList[k].inNum;
			if (0 == graphList->adjList[k].inNum)
				mStack.push(k);
			
			pEdgeNode = pEdgeNode->next;
		}
	}

	return nCnt != MAXVEX;
}


//int main()
//{
//	GraphAdjList mGraph;
//	InitGraph(&mGraph);
//	cout << "创建图：" << endl;
//	CreatGraph(&mGraph);
//	cout << "打印图的邻接表逻辑结构：" << endl;
//	PrintGraph(&mGraph);
//	cout << "拓扑排序路径：" << endl;
//	bool bAcire = TopologicalSort(&mGraph);
//	cout << endl;
//	cout << "存在回环? " << bAcire << endl;
//}

//测试数据
/*
输入6个顶点信息（顶点 入度）:
0 2
1 2
2 1
3 1
4 0
5 0
输入6条边的信息：
5 0
5 2
2 3
3 1
4 1
4 0

打印图的邻接表逻辑结构：
打印邻接表的逻辑图：
索引号   入度数   data  ： 出度索引值
  0        2        0
  1        2        1
  2        1        2    ： 3
  3        1        3    ： 1
  4        0        4    ： 0  1
  5        0        5    ： 2  0

拓扑排序路径;
5-->2-->3-->4-->1-->0



*/