深度优先搜索(dfs)

概念

       与树的遍历类似，我们希望从图的某一顶点出发访遍图中其余节点，并且使每一个顶点仅被访问一次。这个过程就叫做图的遍历。

       由于图的连接可能存在环路，沿着边依次访问的过程可能会使得某个顶点被访问多次，所以可以使用辅助数组visited[0…n-1]记录某个顶点是否已经被访问。它的初始值可以是false,如果某个顶点i被访问过了，就将visited[i]置为true.

       深度优先遍历类似于先根遍历，从某个顶点v出发，访问此顶点，然后依次从v的未被访问的邻接点出发继续深度优先遍历，直到所有与v相通的顶点都被访问到。则选择图中另一个没有被访问过的顶点做起始点，继续上述过程。知道图中所有的节点都被访问。

图示

 

对于如图所示的图形，先从0开始访问，然后选择0的邻接点1，然后1的邻接点3，然后选择3的邻接点7，然后选择7的邻接点4.

       对于4而言，他的两个邻接点都被访问，回溯的7，对7而言，它的两个邻接点也都被访问，回溯到3，3的两个邻接点也都被访问，回溯到1，1的两个邻接点也都被访问，回溯到0，0的邻接点2没有被访问。

       访问2，然后选择2的邻接点5，选择5的邻接点6

       6的两个邻接点都被访问，回溯到5，5的两个邻接点都被访问，回溯到2，2的两个邻接点都被访问，回溯到0，0的两个邻接点都被访问。一次对于0开始的访问结束。

       后面接着根据visited[]里的值判断剩余的顶点是否被访问过，由于剩余的顶底都被访问过了，所以将本图遍历了一遍。

       遍历的顺序应该为0->1->3->7->4->2->5->6

算法(伪代码)

Void DFSTraverse(Graph G){

       Visited[] = new Boolean[G.size()];

       For(i = 0;I < G.size();i++)visited[i] = false;

       For(I = 0; I < G.size();i++){

              If(!visited[i])dfs(I,G,visited);

       }

}

Void dfs(int I ,Graph G,visited){

       Visited[i] = true;

       Print(i);

       For(int v : i的邻接表){

              If(!visited[v])dfs(v,G,visited);

       }

}     

代码

public class Solution {
    public static void main(String[] args) {
        List<Integer> l0 = new ArrayList<>();
        List<Integer> l1 = new ArrayList<>();
        List<Integer> l2 = new ArrayList<>();
        List<Integer> l3 = new ArrayList<>();
        List<Integer> l4 = new ArrayList<>();
        List<Integer> l5 = new ArrayList<>();
        List<Integer> l6 = new ArrayList<>();
        List<Integer> l7 = new ArrayList<>();
        List<List<Integer>> graph = new ArrayList<>();
        l0.add(1);
        l0.add(2);
        graph.add(l0);
        l1.add(3);
        l1.add(4);
        graph.add(l1);
        l2.add(5);
        l2.add(6);
        graph.add(l2);
        l3.add(1);
        l3.add(7);
        graph.add(l3);
        l4.add(1);
        l4.add(7);
        graph.add(l4);
        l5.add(2);
        l5.add(6);
        graph.add(l5);
        l6.add(2);
        l6.add(5);
        graph.add(l6);
        l7.add(3);
        l7.add(4);
        graph.add(l7);
        DFSTraverse(graph);
    }
    public static void DFSTraverse(List<List<Integer>> graph){
        boolean[] visited = new boolean[graph.size()];
        for(int i = 0;i < visited.length;i++)visited[i] = false;
        for(int i = 0;i < graph.size();i++){
            if(!visited[i]){
                dfs(i,graph,visited);
            }
        }
    }
    public static void dfs(int i,List<List<Integer>> graph,boolean[] visited){
        visited[i] = true;
        System.out.println(i + " has been visited!");
        for(int v : graph.get(i)){
            if(!visited[v]){
                dfs(v,graph,visited);
            }
        }
    }
}

 

总结

深度优先搜索的时间复杂度为O(n+e).n为顶点个数，e为弧的个数。