在java中使用拓扑排序实现DFS时出错

我想使用DFS对该图进行排序，以解决拓扑排序问题：

我使用了给定的java代码，得到了一个不正确的输出，因为输出中的g和e在b之前，根据对流层排序，b必须首先出现。我做错了什么

代码是：

class vertex{
    public char label;
    public vertex(char lab)
    {
        label = lab;
    }
}
class DFS {

    private final int Size = 10;
    private final vertex vertexList[];
    private final int adjList[][];
    private int nVerts;
    private final char sortedArray[];

    public DFS(){
        vertexList = new vertex[Size];
        adjList = new int [Size][Size];
        nVerts = 0;
        sortedArray = new char[Size];
    }


    public void addVertex(char lab) {
        vertexList[nVerts++] = new vertex(lab);
    }

    public void addEdge(int start, int end) {
        adjList[start][end] = 1;
    }

    public void displayVertex(int v) {
        System.out.println(vertexList[v].label);
    }

    public void topo() {
        int orig_nVerts = nVerts;

        while (nVerts>0) {
            int currentVertex = noSuccessors();
            if (currentVertex == -1)
            {
                System.out.println("Error: Graph has cycle");
                return;
            }
            sortedArray[nVerts-1]= vertexList[currentVertex].label;
            deleteVertex(currentVertex);
        }
        System.out.println("The DFS graph using topological sort: ");
        for (int i =0; i<orig_nVerts; i++)
        {
            System.out.print(sortedArray[i] + " ");
        }
        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(adjList[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++) {
            adjList[row][col] = adjList[row+1][col];
        }
    }

    private void movecolLeft(int col, int length) {
        for (int row= 0; row<length; row++) {
            adjList[row][col] = adjList[row][col+1];
        }
    }

}

public class TopologicalSort {
    public static void main(String[] args)
    {
        DFS D = new DFS();
        D.addVertex('d');
        D.addVertex('a');
        D.addVertex('c');
        D.addVertex('b');
        D.addVertex('g');
        D.addVertex('f');
        D.addVertex('e');

        D.addEdge(0, 1); //da
        D.addEdge(0, 3); //db
        D.addEdge(0, 2); //dc
        D.addEdge(0, 5); //df
        D.addEdge(0, 4); //dg
        D.addEdge(1, 3); //ab
        D.addEdge(1, 2); //ac
        D.addEdge(2, 4); //bg
        D.addEdge(2, 6); //be
        D.addEdge(3, 5); //cf
        D.addEdge(4, 5); //gf
        D.addEdge(4, 6); //ge

        D.topo();
    }
}

类顶点{
公共字符标签；
公共顶点（字符实验室）
{
标签=实验室；
}
}
类DFS{
私有最终整数大小=10；
私有最终顶点顶点列表[]；
私有最终整数调整列表[]；
私人投资；
Darray[]的私人最终许可证；
公共DFS（）{
vertexList=新顶点[大小]；
adjList=新整数[大小][大小]；
nVerts=0；
SorterDarray=新字符[大小]；
}
公共void addVertex（字符实验室）{
vertexList[nVerts++]=新顶点（实验室）；
}
公共无效添加（整数开始，整数结束）{
adjList[start][end]=1；
}
公共void显示顶点（int v）{
System.out.println（vertexList[v].label）；
}
公共空间地形图（）{
int orig_nVerts=nVerts；
而（nVerts>0）{
int currentVertex=noSuccessors（）；
如果（currentVertex==-1）
{
System.out.println（“错误：图形有循环”）；
返回；
}
sortedArray[nVerts-1]=顶点列表[currentVertex]。标签；
deleteVertex（currentVertex）；
}
System.out.println（“使用拓扑排序的DFS图：”）；
对于（int i=0；i），请释放并添加预期输出。