java拓扑排序实现源码

package main;

import java.util.List;
/**
* @Title:java拓扑排序
* @Author:Ted
* @Date:2014-12-12 下午4:18:49
*/
public class node {

private Integer inDegree;//入度
private Integer outDegree;//出度
private Integer du;//历时
private Integer ls;//最晚开始时间
private List<String>  inName;//指向我的节点（如，该节点是B，且ACD都指向B，那么存ACD）
private String  name="";//本节点名字
private String outName="";//指向哪些节点

public node(String name,List<String> list,Integer du){
this.name=name;
this.inName=list;
this.du=du;
}
node(){}

public Integer getInDegree() {
return this.inName.size();
}
public void setInDegree(Integer inDegree) {
this.inDegree = inDegree;
}
public Integer getOutDegree() {
return outDegree;
}
public void setOutDegree(Integer outDegree) {
this.outDegree = outDegree;
}
public Integer getDu() {
return du;
}
public void setDu(Integer du) {
this.du = du;
}
public List<String> getInName() {
return inName;
}
public void setInName(List<String> inName) {
this.inName = inName;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getOutName() {
return outName;
}
public void setOutName(String outName) {
this.outName = outName;
}

@Override
public String toString() {
return "node [name=" + name + ", inName=" + inName + ", inDegree="
+ getInDegree() + "]";
}

}

package main;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
* @Title:java拓扑排序
* @Author:Ted
* @Date:2014-12-12 下午4:18:49
*/
public class Toplogical {
private static Queue<node> queue = (Queue<node>) new LinkedList<node>();
private static int count =0;

//手动创建多个拓扑节点
public static List<node> createNode() {
String[] inName0 = {};
String[] inName1 = {};
String[] inName2 = { "b" };
String[] inName3 = { "a", "b" };
String[] inName4 = { "d" };
String[] inName5 = { "c", "d" };
String[] inName6 = { "e", "f" };
node[] n = new node[7];
n[0] = new node("a", Arrays.asList(inName0), 5);
n[1] = new node("b", Arrays.asList(inName1), 7);
n[2] = new node("c", Arrays.asList(inName2), 2);
n[3] = new node("d", Arrays.asList(inName3), 6);
n[4] = new node("e", Arrays.asList(inName4), 9);
n[5] = new node("f", Arrays.asList(inName5), 5);
n[6] = new node("g", Arrays.asList(inName6), 3);
List<node> nodeList = new LinkedList<node>();
System.out.println("初始nodeList为");
for (int i = 0; i < n.length; i++) {
nodeList.add(i, n[i]);
System.out.println(nodeList.get(i));
}
return nodeList;
}

//对传进来的LinkedList进行冒泡排序
public static List<node> sort(List<node> nodeList){
count++;
System.out.println("-----------第"+count+"轮排序----------");
node temp = new node();
for (int i = 0; i < nodeList.size(); i++) {
for (int j = i; j < nodeList.size(); j++) {
if (nodeList.get(i).getInDegree() > nodeList.get(j).getInDegree()) {
temp = nodeList.get(i);
nodeList.set(i, nodeList.get(j));
nodeList.set(j, temp);
}
}
}
for(int i=0;i<nodeList.size();i++){
System.out.println(nodeList.get(i));
}

return nodeList;
}

//删除节点及边
public static List<node> removeNode(List<node> nodeList,String Name){
for(int i=0;i<nodeList.size();i++){
//如果是最后一个节点，那么直接返回这个节点
if(nodeList.size()==1){
return nodeList;
}
//删除全部节点中某个节点
if(nodeList.get(i).getName().equals(Name)){
nodeList.remove(i);
}
//删除包含某个节点的边
//假如B节点中inName包含A,C。而要删除的是A，那么把C复制出来并回填给B
if(nodeList.get(i).getInName().contains(Name)){
List<String> strList =new LinkedList<String>();
for(int j=0;j<nodeList.get(i).getInName().size();j++){
if(!nodeList.get(i).getInName().get(j).equals(Name)){
strList.add(nodeList.get(i).getInName().get(j));
}
}
node n=new node(nodeList.get(i).getName(),strList,nodeList.get(i).getDu());
nodeList.set(i, n);
}
}
return nodeList;
}

public static void main(String[] args){
List<node> nodeList = createNode();
int nodeCount = nodeList.size();
//	System.out.println("nodeCount:"+nodeCount);
nodeList = sort(nodeList);
for(int i=0;i<nodeCount;i++){
//把排序后的节点的第一个压入队列
queue.offer(nodeList.get(0));
//把排序后的节点第一个删除
nodeList = removeNode(nodeList, nodeList.get(0).getName());
//最后一轮不必排序，为了提升效率所以省掉最后一次排序
if(i==nodeCount-1)break;
//对nodeList按照入度从小到大排序
nodeList = sort(nodeList);
}
System.out.println("\n"+"最终拓扑排序为");//输出并移除队列头
for (int i = 0; i < nodeCount; i++) {
System.out.println(i+" "+queue.remove());//输出并移除队列头
}
}
}