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

转载至：http://blog.csdn.net/andyelvis/article/details/1728378

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

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

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