JAVA实现拓扑排序

折腾了很久才实现的拓扑排序，把代码和思路整理一下：

拓扑排序是用来对有向无环图进行排序的，和图的广度优先遍历类似，主要是利用队列把节点的入度为0（就是没有指向该节点的节点，只有从节点发出的）的元素入队，然后

1：将队首元素出队输出并寻找该元素的所有相邻元素的节点，

2：对这些节点的入度-1，并检查是否有入度减为0的，如有，则入队。

重复上述操作直到队列为空为止。

容易出问题的地方是图的建立，邻接矩阵的建立比较浪费内存，这里我是使用邻接表来建立的。这里采用两个类Vertex和Edge表示节点和边，每个Vertex的成员有一个String元素表示该节点的内容，一个Edge对象表示以该节点为起点的边，该边初始为null。每个Edge的成员有一个String元素表示该边指向的节点内容，一个Edge代表以该String元素为起点的另一条边，也就是利用链表将一个起点发出的边连接起来。

下面给出代码

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class TopSort {

Graph g ;

public static void main(String[] args)
{
Graph g = new Graph();
TopSort ts = new TopSort(g);
ts.topSort();
}

public TopSort(Graph g)
{
this.g = g;
g.buildGraph();
}

public void topSort()
{
Queue<Vertex> queue= new LinkedList<Vertex>();

int length = g.getLength();
for(int i=0;i<length;i++)
{
//首先把入度为0的所有节点入队
if(g.getEnterEdgeNumber(g.v[i])==0)
{
queue.add(g.v[i]);
}
}

System.out.print("拓扑顺序为：");
while(!queue.isEmpty())
{
//队首出列，并找到相邻节点
Vertex ver = queue.poll();
ArrayList<Vertex> al = g.getAdjacentVertex(ver);
for(Vertex vertex: al)
{
System.out.print(ver.from+" ");
if(--vertex.indegree == 0)
queue.add(vertex);
}

}
}
}

class Graph {

public Vertex[] v ;
public  Edge[] e;
public  int edgeNumber;
public  int vertexNumber;

//根据输入建立一个有向图
public void buildGraph()
{
System.out.print("输入顶点数和边数：");
Scanner s = new Scanner(System.in);
vertexNumber = s.nextInt();
edgeNumber = s.nextInt();
System.out.println();
//建立顶点数组
v = new Vertex[vertexNumber];
e = new Edge[edgeNumber];

System.out.println("输入节点名称：");

for(int i = 0;i < vertexNumber ;  i++)
{
String name = s.next();
v[i] = new Vertex(name);
// v[i].vIndex = i;
}

for(int i = 0;i< edgeNumber ; i++)
{
System.out.print("输入起点和终点:");
String startVertex = s.next();
String endVertex = s.next();

//找到起点的vertex索引值
int vBeginIndex=findvIndex(startVertex),
vEndIndex=findvIndex(endVertex);

e[i]= new Edge(endVertex);//由终点建立到该终点的边
v[vEndIndex].indegree++;//相应Vertex的入度+1
//e[i].eIndex = i;

e[i].nextEdge = v[vBeginIndex].first;//将该边的下一条边连接到以startVertex的所有边
v[vBeginIndex].first = e[i];//将e作为v[startVertex]的第一条边
}
}

public int getLength()
{
return v.length;
}

//返回一个包含相邻节点的ArrayList
public ArrayList<Vertex> getAdjacentVertex(Vertex ver)
{
int index ;
ArrayList al = new ArrayList();

//找到指向ver的相邻节点
for(int j=0; j < v.length;j++)
{
if(v[j].first != null )
for(Edge e = v[j].first;e!=null;e= e.nextEdge)
if(e.to.equals(ver.from))
{
al.add(v[j]);
}
}
index = findvIndex(ver.from);
//找到以ver为起点指向的相邻节点
for(Edge e = v[index].first;e != null; e = e.nextEdge)
{
al.add( v[findvIndex(e.to)] );
}

return al;

}

//返回一个节点的入度（有几个节点直接指向该节点）
public int getEnterEdgeNumber(Vertex ver)
{
int counter =0 ;
for(int i =0;i<edgeNumber; i++)
{
if(e[i].to.equals(ver.from))
counter++;
}
return counter;
}

public int findvIndex(String s)
{
int vIndex=-1;
for(int j=0;j<v.length;j++)
{
if(v[j].from.equals(s))
vIndex = j;
}
return vIndex;
}

}

/*
* 表示图中的点，其成员有自身关键字和一条以该节点为起点的边
*/
class Vertex {

//int vIndex;
String from;//边的起点
int indegree;//每个顶点的入度
Edge first;//以from为起点的第一条边
public Vertex(String from)
{
this.from = from;
first = null;
this.indegree = 0;
}

}

/*
* 表示图中的点，其成员有自身关键字和一条以该节点为起点的边
*/
class Vertex {

String from;//边的起点
int indegree;//每个顶点的入度
Edge first;//以from为起点的第一条边
public Vertex(String from)
{
this.from = from;
first = null;
this.indegree = 0;
}

}

运行结果：

输入顶点数和边数：6 7

输入节点名称：

A B C D E F

输入起点和终点:A C

输入起点和终点:A D

输入起点和终点:A E

输入起点和终点:D F

输入起点和终点:F E

输入起点和终点:B E

输入起点和终点:C B

拓扑顺序为：A D C F B E