图的遍历

DFS深度优先遍历：

1 .将顶点元素取出，标记该节点已经被访问过，放入栈中

2 .从栈中将顶点元素peek出来，查找他的没有被访问过的邻居节点，如果不存在，则将该顶点从栈中pop出来，如果存在邻居节点则将其标记为访问过，输出，入栈

3 .循环步骤2直至 栈为空

BFS广度优先遍历：

1.取出根节点，放入队列中,标记该节点已被访问过true

2.将队列中的根节点poll出来，访问他的所有相邻的节点，将他们的访问标记置为false，并将它们一一入栈

3.循环步骤直至队列为空

package GraphNew;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
public class SearchGraph {
    //顶点数组
    public Vertex[] vertexlist;
    //二维邻接矩阵
    public int[][] adj;
    //顶点个数
    public int nvertext;
    public SearchGraph(int N){
        vertexlist = new Vertex[N];
        adj = new int[N][N];
        nvertext = 0;
    }

    //添加顶点
    public void addVertex(int key){
        vertexlist[nvertext++] = new Vertex(key);
    }

    //添加边
    public void addEdge(int start , int end){
        adj[start][end] = 1;
        adj[end][start] = 1;
    }

    public int findadjunused(int v){
        for(int i=0; i<nvertext;i++)
        {
            if(adj[i][v] == 1 && vertexlist[i].visted==false)
                return i;
        }
        return -1;
    }
    //图的深度优先遍历
    public void dfs()
    {
        //首先访问零号节点  将访问标记置为true
        vertexlist[0].visted=true;
        //输出该顶点
        System.out.println(vertexlist[0].data);
        //将该顶点压入栈中
        Stack<Integer> stack = new Stack<Integer>();
        stack.push(vertexlist[0].data);
        //判断栈是否为空
        while(!stack.isEmpty())
        {
            //将栈中元素取出
            //遍历邻接矩阵 获取它的相邻且未被访问过的节点
            int node = findadjunused(stack.peek());
            //如果没有可以访问的节点，则将此节点pop
            if(node==-1)
            {
                stack.pop();
            }
            else 
            {
                //如果有的话,则将其标记为已经访问过
                vertexlist[node].visted = true;
                stack.push(node);
                System.out.println(node);
            }
        }
    }

    //图的广度优先遍历
    public void bfs(){
        //首先访问零号节点  将访问标记置为true
        vertexlist[0].visted=true;
        System.out.println(vertexlist[0].data);
        //将该顶点放入队列中
        Queue<Integer> queue = new LinkedList<Integer>();
        queue.add(vertexlist[0].data);

        while(!queue.isEmpty())
        {
            int root = queue.poll();
            for(int i=0; i<nvertext; i++)
            {
                if(adj[root][i]==1 && vertexlist[i].visted==false)
                {
                    vertexlist[i].visted = true;
                    System.out.println(vertexlist[i].data);
                    queue.add(i);
                }
            }
        }
    }

    public static void main(String args[]){
        SearchGraph g=new SearchGraph(10);
        for(int i=0;i<10;i++)
        {
            g.addVertex(i);
        }
        g.addEdge(0, 1);
        g.addEdge(0, 4);
        g.addEdge(1, 4);
        g.addEdge(1, 3);
        g.addEdge(1, 2);
        g.addEdge(3, 4);
        g.addEdge(3, 2);
        g.addEdge(3, 5);
        g.addEdge(3, 2);
        g.addEdge(2, 6);
        g.addEdge(4, 7);
        g.addEdge(5, 8);
        g.addEdge(3, 6);
        g.addEdge(6, 9);
        System.out.println("深度优先遍历");
        g.dfs();
        System.out.println("广度优先遍历");
        g.bfs();
    }
}

/*
 * 顶点类
 * 包含标记访问符号
 */
class Vertex{
    int data;
    public boolean visted;
    public Vertex(int data) {
        super();
        this.data = data;
    }

}