图

public class TestForString{
public static void main(String[] arg){

}

}

class StackX{
private final int SIZE = 20;
private int[] st;
private int top;

public StackX(){
    st = new int[SIZE];
    top = -1;
}

public void push(int j){
    st[++top]=j;
}

public int pop(){
    return st[top--];
}

public int peek(){
    return st[top];
}

public boolean isEmpty(){
    return top==-1;
}

}

class Vertex{
public char label;
public boolean wasVisited;

public Vertex(char lab){
    label = lab;
    wasVisited = false;
}

}

class Graph{
private final int MAX_VERTS = 20;
private int[][] adjMat;
private Vertex[] vertexList;
private int nVerts;
private StackX theStack;

public Graph(){
    nVerts = 0;
    vertexList = new Vertex[MAX_VERTS];
    adjMat = new int[MAX_VERTS][MAX_VERTS];
    for(int i=0;i<MAX_VERTS;i++){
        for(int j=0;j<MAX_VERTS;j++){
            adjMat[i][j]=0;
        }
    }
    theStack = new StackX();
}

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



public void deleteVertex(int j){



    for(;j<nVerts-1;j++){
        vertexList[j]=vertexList[j+1];
    }
    moveColLeft(j);
    moveRowUp(j);
    nVerts--;

}

public void moveColLeft(int j){
    for(;j<nVerts-1;j++){
        for(int i=0;i<nVerts;i++){
            adjMat[i][j]=adjMat[i][j+1];
        }
    }
}

public void moveRowUp(int j){
    for(;j<nVerts-1;j++){
        adjMat[j]=adjMat[j+1];
    }
} 

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

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

public void dfs(){
    vertexList[0].wasVisited=true;
    theStack.push(0);

    while(!theStack.isEmpty()){
        int current = theStack.peek();
        int i=0;
        for(;i<nVerts;i++){
            if(adjMat[current][i]==1&&vertexList[i].wasVisited==false){
                theStack.push(i);
                vertexList[i].wasVisited = true;
                displayVertex(i);
                break;
            }
        }
        if(i==nVerts){
            theStack.pop();
        }
    }
}

private static class Queue{
    int head;
    int tail;
    int num;
    int[] array;
    final static int MaxSize = 20;

    public Queue(){
        head = 0;
        tail = -1;
        num=0;
        array = new int[MaxSize];
    }

    public void offer(int j){
        if(num<MaxSize-1){
            tail++;
            tail%=MaxSize;
            array[tail]=j;
            num++;
        }
    }

    public int poll(){
        if(num>0){
            int temp = array[head++];
            num--;
            head%=MaxSize;
            return temp;
        }
        return -1;
    }

    public boolean isEmpty(){
        return num==0;
    }
}

public void bfs(){
    Queue queue = new Queue();
    queue.offer(0);
    vertexList[0].wasVisited = true;

    while(!queue.isEmpty()){
        int current = queue.poll();
        for(int i=0;i<nVerts;i++){
            if(adjMat[current][i]==1&&vertexList[i].wasVisited==false){
                queue.offer(i);
            }
        }
    }
}

public void topo(){
    int orig_nVerts = nVerts;
    char[] sortedArray = new char[nVerts];
    int indexOfSortedArray = 0;
    while(nVerts>0){
        int current = noSuccessor();
        if(current==-1){
            System.out.println("There must be a circle");
            return;
        }
        sortedArray[nVerts-1]=vertexList[current].label;
        deleteVertex(current);

    } 
}

private int noSuccessor() {
    // TODO Auto-generated method stub

    for(int i=0;i<nVerts;i++){
        int j=0;
        for(;j<nVerts;j++){
            if(adjMat[i][j]==1){
                break;
            }
        }
        if(j==nVerts){
            return i;
        }
    }
    return -1;
}

}