十七、拓扑排序

拓扑排序介绍

拓扑排序(Topological Order)是指，将一个有向无环图(Directed Acyclic Graph简称DAG)进行排序进而得到一个有序的线性序列。

这样说，可能理解起来比较抽象。下面通过简单的例子进行说明！ 
例如，一个项目包括A、B、C、D四个子部分来完成，并且A依赖于B和D，C依赖于D。现在要制定一个计划，写出A、B、C、D的执行顺序。这时，就可以利用到拓扑排序，它就是用来确定事物发生的顺序的。

在拓扑排序中，如果存在一条从顶点A到顶点B的路径，那么在排序结果中B出现在A的后面。

拓扑排序的算法图解

以上图为例，来对拓扑排序进行演示。

第1步：将B和C加入到排序结果中。 
    顶点B和顶点C都是没有依赖顶点，因此将C和C加入到结果集T中。假设ABCDEFG按顺序存储，因此先访问B，再访问C。访问B之后，去掉边<B,A>和<B,D>，并将A和D加入到队列Q中。同样的，去掉边<C,F>和<C,G>，并将F和G加入到Q中。 
    (01) 将B加入到排序结果中，然后去掉边<B,A>和<B,D>；此时，由于A和D没有依赖顶点，因此并将A和D加入到队列Q中。 
    (02) 将C加入到排序结果中，然后去掉边<C,F>和<C,G>；此时，由于F有依赖顶点D，G有依赖顶点A，因此不对F和G进行处理。 
第2步：将A,D依次加入到排序结果中。 
    第1步访问之后，A,D都是没有依赖顶点的，根据存储顺序，先访问A，然后访问D。访问之后，删除顶点A和顶点D的出边。 
第3步：将E,F,G依次加入到排序结果中。

因此访问顺序是：B -> C -> A -> D -> E -> F -> G

邻接矩阵：

class Vertex
{
    public char label;
    public Vertex(char lab)
    {
        label = lab;
    }
}

class DGraph
{
    private final int MAX_VERTS = 20;
    private int nVerts;
    private Vertex vertexList[];
    private int adjMat[][];
    private char sortedArray[];
    
    public DGraph()
    {
        vertexList = new Vertex[MAX_VERTS];
        adjMat = new int[MAX_VERTS][MAX_VERTS];
        nVerts = 0;
        for(int i=0;i<MAX_VERTS;i++)
            for(int j=0;j<MAX_VERTS;j++)
                adjMat[i][j] = 0;
        sortedArray = new char[MAX_VERTS];
    }
    
    public void addVertex(char lab)
    {
        vertexList[nVerts++] = new Vertex(lab);
    }
    
    public void addEdge(int start,int end)
    {
        adjMat[start][end] = 1;
    }
    
    public void displayVertex(int v)
    {
        System.out.println(vertexList[v].label);
    }
    
    public void topologicalSort()
    {
        int orig_nVerts = nVerts;
        while(nVerts>0)
        {
            int currentVertex = noSuccessors();
            if(currentVertex == -1)
            {
                System.out.println("Error:Graph has cycles");
                return ;
            }
　　　　　　　//先找到拓扑排序的最后的节点
            sortedArray[nVerts-1] = vertexList[currentVertex].label;
            deleteVertex(currentVertex);
        }
        System.out.print("Topologically sorted order:");
        for(int j=0;j<orig_nVerts;j++)
            System.out.println(sortedArray[j]);
        System.out.println();
    }
    
　　//找到一个节点没有后继
    public int noSuccessors()
    {
        boolean isEdge;
        for(int row=0;row<nVerts;row++)
        {
            isEdge = false;
            for(int col=0;col<nVerts;col++)
            {
                if(adjMat[row][col]>0)
                {
                    isEdge = true;
                    break;
                }
            }
            if(!isEdge)
                return row;
        }
        return -1;
    }
    
    public void deleteVertex(int delVert)
    {
        if(delVert != nVerts-1)
        {
            for(int j=delVert;j<nVerts-1;j++)
                vertexList[j] = vertexList[j+1];
            for(int row=delVert;row<nVerts-1;row++)
                moveRowUp(row,nVerts);
            for(int col=delVert;col<nVerts-1;col++)
                moveColLeft(col,nVerts-1);
        }
        nVerts--;
    }
    
    private void moveRowUp(int row,int length)
    {
        for(int col=0;col<length;col++)
            adjMat[row][col] = adjMat[row+1][col];
    }
    
    private void moveColLeft(int col,int length)
    {
        for(int row=0;row<length;row++)
            adjMat[row][col] = adjMat[row][col+1];
    }
    
}

public class MatrixDG_TOPO 
{
    public static void main(String[] args)
    {
          DGraph theGraph = new DGraph();
          theGraph.addVertex('A');    // 0
          theGraph.addVertex('B');    // 1
          theGraph.addVertex('C');    // 2
          theGraph.addVertex('D');    // 3
          theGraph.addVertex('E');    // 4
          theGraph.addVertex('F');    // 5
          theGraph.addVertex('G');    // 6
          theGraph.addVertex('H');    // 7

          theGraph.addEdge(0, 3);     // AD
          theGraph.addEdge(0, 4);     // AE
          theGraph.addEdge(1, 4);     // BE
          theGraph.addEdge(2, 5);     // CF
          theGraph.addEdge(3, 6);     // DG
          theGraph.addEdge(4, 6);     // EG
          theGraph.addEdge(5, 7);     // FH
          theGraph.addEdge(6, 7);     // GH

          theGraph.topologicalSort();            // do the sort
    }
}

邻接链表：

import java.util.ArrayList;
class Vertex
{
    public char label;
    public int index;//数组下标索引编号
    public Edge firstEdge;
    public int inDegree;//入度
    public Vertex(char lab){
        index = 0;
        inDegree = 0;
        label = lab;
        firstEdge = null;
    }
}

class Edge
{
    public int dest;
    public Edge nextEdge;
    public Edge(int dest)
    {
        this.dest= dest;
        nextEdge = null;
    }
}

class DGraph
{
    private final int MAX_VERTS = 20;
    private int nVerts = 0;
    private Vertex[] vertexList;
    private ArrayList<Vertex> topoList;
    
    public DGraph()
    {
        vertexList = new Vertex[MAX_VERTS];
        topoList = new ArrayList<Vertex>();
    }
    
    public void addVertex(Vertex vertex)
    {
        vertex.index = nVerts;
        vertexList[nVerts++] = vertex;
    }
    
    public void addEdge(int start,int end)
    {
        vertexList[end].inDegree++;
        Edge endEdge = new Edge(end);
        Edge currentEdge = vertexList[start].firstEdge;
        if(currentEdge==null)
        {
            vertexList[start].firstEdge = endEdge;
        }else
         {
            while(currentEdge.nextEdge!=null)
                currentEdge = currentEdge.nextEdge;
            currentEdge.nextEdge = endEdge;
        }
    }
    
    public void topologicalSort()
    {
        for(int i=0;i<nVerts;i++)
        {
            Vertex vertex = noPrevious();
            if(vertex == null)
            {
                System.out.println("Error:Graph has cycles");
                return ;
            }
            topoList.add(vertex);
            deleteVertex(vertex);
        }
    }
    
    public Vertex noPrevious()
    {
        int i=0;
        for( ;i<nVerts;i++)
        {
            if(vertexList[i] != null && vertexList[i].inDegree==0)
                break;
        }
        if(i==nVerts)
            return null;
        else
            return vertexList[i];
    }
    
    public void deleteVertex(Vertex vertex)
    {
        Edge currentEdge = vertex.firstEdge;
        if(currentEdge == null)
            return;
        while(currentEdge != null){
            vertexList[currentEdge.dest].inDegree--;
            currentEdge = currentEdge.nextEdge;
        }
/*        //删除顶点数组中的一个顶点
        for(int j=vertex.index;j<nVerts-1;j++){
            vertexList[j] = vertexList[j+1]; 
            vertexList[j].index = j;
        }*/
        vertexList[vertex.index] = null;
        //nVerts--;
    }
    
    public void displayTopo()
    {
        System.out.println("topologicalSort:");
        for(int i=0;i<topoList.size();i++)
            System.out.print(topoList.get(i).label);
        System.out.println("");
    }
    
}

public class ListDG_TOPO 
{
    public static void main(String[] args) 
    {
          DGraph theGraph = new DGraph();
          theGraph.addVertex(new Vertex('A'));// 0
          theGraph.addVertex(new Vertex('B'));// 1
          theGraph.addVertex(new Vertex('C'));// 2
          theGraph.addVertex(new Vertex('D'));// 3
          theGraph.addVertex(new Vertex('E'));// 4
          theGraph.addVertex(new Vertex('F'));// 5
          theGraph.addVertex(new Vertex('G'));// 6
          theGraph.addVertex(new Vertex('H'));// 7

          theGraph.addEdge(0, 3);// AD
          theGraph.addEdge(0, 4);// AE
          theGraph.addEdge(1, 4);// BE
          theGraph.addEdge(2, 5);// CF
          theGraph.addEdge(3, 6);// DG
          theGraph.addEdge(4, 6);// EG
          theGraph.addEdge(5, 7);// FH
          theGraph.addEdge(6, 7);// GH
          theGraph.addEdge(2, 1);// CB
          theGraph.addEdge(6, 5);// GF

          theGraph.topologicalSort();
          theGraph.displayTopo();
    }
}