深度优先搜索与广度优先搜索

原文转自：http://blog.csdn.net/andyelvis/archive/2007/08/06/1728378.aspx

有两种常用的方法可用来搜索图：即深度优先搜索和广度优先搜索。它们最终都会到达所有连通的顶点。深度优先搜索通过栈来实现，而广度优先搜索通过队列来实现。

深度优先搜索：
下面图中的数字显示了深度优先搜索顶点被访问的顺序。



为了实现深度优先搜索，首先选择一个起始顶点并需要遵守三个规则：
(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;


}


}




}