深度优先搜索和广度优先搜索

有两种常用的方法可用来搜索图：即深度优先搜索和广度优先搜索。它们最终都会到达所有连通的顶点。深度优先搜索通过栈来实现，而广度优先搜索通过队列来实现。
深度优先搜索：下面图中的数字显示了深度优先搜索顶点被访问的顺序。为了实现深度优先搜索，首先选择一个起始顶点并需要遵守三个规则： (1) 如果可能，访问一个邻接的未访问顶点，标记它，并把它放入栈中。 (2) 当不能执行规则1时，如果栈不空，就从栈中弹出一个顶点。 (3) 如果不能执行规则1和规则2，就完成了整个搜索过程。
广度优先搜索：在深度优先搜索中，算法表现得好像要尽快地远离起始点似的。相反，在广度优先搜索中，算法好像要尽可能地靠近起始点。它首先访问起始顶点的所有邻接点，然后再访问较远的区域。它是用队列来实现的。下面图中的数字显示了广度优先搜索顶点被访问的顺序。实现广度优先搜索，也要遵守三个规则： (1) 访问下一个未来访问的邻接点，这个顶点必须是当前顶点的邻接点，标记它，并把它插入到队列中。 (2) 如果因为已经没有未访问顶点而不能执行规则1时，那么从队列头取一个顶点，并使其成为当前顶点。 (3) 如果因为队列为空而不能执行规则2，则搜索结束。
下面是一个图类的java代码，dfs()为深度优先搜索算法，bfs()为广度优先搜索算法：

//用于实现深度优先搜索的栈类
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 Queue{
    private final int SIZE=20;
    private int[] queArray;
    private int front;
    private int rear;
    public Queue(){
        queArray=new int[SIZE];
        front=0;
        rear=-1;
    }
    public void insert(int j){
        if(rear==SIZE-1)
            rear=-1;
        queArray[++rear]=j;
    }
    public int remove(){
        int temp=queArray[front++];
        if(front==SIZE)
            front=0;
        return temp;
    }
    public boolean isEmpty(){
        return ((rear+1==front)||(front+SIZE-1==rear));
    }
}
//顶点类
class Vertex{
    public char label;
    public boolean wasVisited;
    public Vertex(char lab){
        label=lab;
        wasVisited=false;
    }
}
//图类
public class Graph {
    
    private final int MAX_VERTS=20;
    private Vertex vertexList[];
    private int adjMat[][];
    private int nVerts;
    private StackX theStack;
    private Queue theQueue;
    
    /** Creates a new instance of Graph */
    public Graph() {
        vertexList=new Vertex[MAX_VERTS];
        adjMat=new int[MAX_VERTS][MAX_VERTS];
        nVerts=0;
        for (int j = 0; j < MAX_VERTS; j++) {
            for (int k = 0; k < MAX_VERTS; k++) {
                adjMat[j][k]=0;
            }
        }
        theStack=new StackX();
        theQueue=new Queue();
    }
    //增加一个顶点
    public void addVertex(char lab){
        vertexList[nVerts++]=new Vertex(lab);
    }
    //增加一条边
    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;
        displayVertex(0);
        theStack.push(0);
        while(!theStack.isEmpty()){
            int v=getAdjUnvisitedVertex(theStack.peek());
            if(v==-1)
                theStack.pop();
            else{
                vertexList[v].wasVisited=true;
                displayVertex(v);
                theStack.push(v);
            }
        }
        for(int j=0;j<nVerts;j++)
            vertexList[j].wasVisited=false;
    }
    //得到与v顶点邻接且未访问过的顶点标号
    public int getAdjUnvisitedVertex(int v){
        for (int j = 0; j < nVerts; j++) {
            if(adjMat[v][j]==1&&vertexList[j].wasVisited==false)
                return j;
        }
        return -1;
    }
    //广度优先搜索
    public void bfs(){
        vertexList[0].wasVisited=true;
        displayVertex(0);
        theQueue.insert(0);
        int v2;
        while(!theQueue.isEmpty()){
            int v1=theQueue.remove();
            while((v2=getAdjUnvisitedVertex(v1))!=-1){
                vertexList[v2].wasVisited=true;
                displayVertex(v2);
                theQueue.insert(v2);
            }
        }
        for (int j = 0; j < nVerts; j++) {
            vertexList[j].wasVisited=false;
        }
    }
    
}

...{

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 Queue...{

private final int SIZE=20;

private int[] queArray;

private int front;

private int rear;

public Queue()...{

queArray=new int[SIZE];

front=0;

rear=-1;

}

public void insert(int j)...{

if(rear==SIZE-1)

rear=-1;

queArray[++rear]=j;

}

public int remove()...{

int temp=queArray[front++];

if(front==SIZE)

front=0;

return temp;

}

public boolean isEmpty()...{

return ((rear+1==front)||(front+SIZE-1==rear));

}

//顶点类

class Vertex...{

public char label;

public boolean wasVisited;

public Vertex(char lab)...{

label=lab;

wasVisited=false;

}

//图类

public class Graph ...{

private final int MAX_VERTS=20;

private Vertex vertexList[];

private int adjMat[][];

private int nVerts;

private StackX theStack;

private Queue theQueue;

/** *//** Creates a new instance of Graph */

public Graph() ...{

vertexList=new Vertex[MAX_VERTS];

adjMat=new int[MAX_VERTS][MAX_VERTS];

nVerts=0;

for (int j = 0; j < MAX_VERTS; j++) ...{

for (int k = 0; k < MAX_VERTS; k++) ...{

adjMat[j][k]=0;

}

theStack=new StackX();

theQueue=new Queue();

}

//增加一个顶点

public void addVertex(char lab)...{

vertexList[nVerts++]=new Vertex(lab);

}

//增加一条边

public void addEdge(int start,int end)