无前趋的顶点优先的拓扑排序方法(JAVA)

无前趋的顶点优先的拓扑排序方法

    该方法的每一步总是输出当前无前趋(即人度为零)的顶点，其抽象算法可描述为：
    NonPreFirstTopSort(G){//优先输出无前趋的顶点
      while(G中有人度为0的顶点)do{
       从G中选择一个人度为0的顶点v且输出之；
       从G中删去v及其所有出边；
       }
      if(输出的顶点数目<|V(G)|)
        //若此条件不成立，则表示所有顶点均已输出，排序成功。
        Error("G中存在有向环，排序失败！")；
     }

import java.util.Arrays;   
import java.util.List;   
import java.util.ArrayList;   
import java.util.Stack;

public class Graph {   
  
    int vertexNum;   //图的顶点数
    ArrayList<ArrayList<Integer>>  table; //图的邻接表，table.get(i)存放与i邻接的顶点
    Stack<Integer> stack;  //存放入度为0的顶点 
    int[] result;   //拓朴排序的结果
    int[] in;// 入度,in[i]表示顶点i的入度   
  
    /**  
     *   
     * 构造一个图  
     *   
     * @param num  
     * 图的顶点数  
     *   
     */  
    public Graph(int num) {   
  
        vertexNum = num;   
        table = new ArrayList<ArrayList<Integer>> (vertexNum);   
         for(int i=0;i<vertexNum;i++)
              table.add(new ArrayList<Integer>());
        stack = new Stack<Integer>();   
        result = new int[vertexNum];   
        in = new int[vertexNum];   
  
    }   
  
    /**  
     * 向图中添加无向边  
     *   
     * @param I  
     *         边的一个顶点  
     * @param J  
     *         边的另一个顶点  
     * @return 是否添加成功  
     */  
    public boolean addEdge(int I, int J) {   
  
        /**  
         * 判断用户输入的是否是一个顶点，如果是，则返回flase,添加不成功  
         */  
        if (J == I) {   
            return false;   
        }   
  
        /**  
         * 判断所输入的顶点值是否在图所顶点范围值内，如果不在，则提示顶点不存在  
         *   
         */  
        if (I < vertexNum && J < vertexNum && I >= 0 && J >= 0) {    
            /**  
             *   
             * 判断边是否存在  
             */  
  
            if (isEdgeExists(I, J)) {    
                return false;   
            }   
  
            /**  
             * 添加边，将孤头的入度加1  
             */  
  
            table.get(I).add(J);   
            in[J]++;   
            return true;   
        }   
        return false;   
    }   
  
    /**  
     * 判断有向边是否存在  
     *   
     * @param i  
     *            要查询的有向边的一个孤尾  
     * @param j  
     *            要查询的有向边的另一个孤头  
     * @return 边是否存在，false:不存在，true:存在  
     */  
  
    public boolean isEdgeExists(int i, int j) {   
  
        /**  
         * 判断所输入的顶点值是否在图所顶点范围值内，如果不在，则提示顶点不存在  
         *   
         */  
        if (i < vertexNum && j < vertexNum && i >= 0 && j >= 0) {   
  
            if (i == j) {   
                return false;   
            }   
  
            /**  
             * 判断i的邻接结点集是否为空  
             */  
  
            if (table.get(i) == null) {   
               return false;
            }   
  
            /**  
             * 判断这条边是否存在，如果存在，则提示边已经存在  
             */  
            for (int q = 0; q < table.get(i).size(); q++) {   
  
                if (((Integer) table.get(i).get(q)).intValue() == j) {   
                 System.out.println("顶点" +i+"和"+"顶点"+j+ "这两点之间存在边");   
                    return true;     
                }   
            }   
        }   
        return false;   
    }   
  
    public void TopSort() {   //无前趋的顶点优先的拓扑排序方法
  
        for (int i = 0; i < vertexNum; i++)   //无前趋的顶点入栈
            if (in[i] == 0)   
                stack.push(i);   
        int k = 0;   
        while (!stack.isEmpty()) {
  
            result[k] = (Integer) stack.pop();   //弹出一个无前趋的顶点,并放入拓扑排序的结果集
  
            if (table.get(result[k]) != null) {  //这个顶点的邻接表非空 
                for (int j = 0; j < table.get(result[k]).size(); j++) {   
  
                    int temp = (Integer) table.get(result[k]).get(j);
                      //对result[k]每一个邻接点进行入度减1操作
                    if (--in[temp] == 0) { //如果temp的入度为0，进栈.
                        stack.push(temp);   
                    }     
                }    
            }   
            k++;     
        }   
  
        if (k < vertexNum) {   
            System.out.println("有回路");   
            System.exit(0);    
        }     
    }   
  
    public int[] getResult() {   
        return result;     
    }   
  
}  

测试：

import java.util.List;   
  
public class GraphTest {   
  
    public static  void main(String args[]){   
        Graph graph = new Graph(6);   
        graph.addEdge(1, 0);   
        graph.addEdge(2, 0);   
        graph.addEdge(3, 0);   
        graph.addEdge(1, 3);   
        graph.addEdge(2, 3);   
        graph.addEdge(3, 5);   
        graph.addEdge(4, 2);   
        graph.addEdge(4, 3);   
        graph.addEdge(4, 5);   
           
        graph.TopSort();   
        int[] list = graph.getResult();   
        System.out.println("拓扑排序的结果为：");   
        for(int i : list){                
            System.out.print(i+"        ");   
        }   
    }   
       
}  

运行:
C:\>java   GraphTest
拓扑排序的结果为：
4        2        1        3        5        0

下载源码