广度优先和深度优先

package test;

import java.util.ArrayList;
import java.util.LinkedList;

public class Graph {
    private int[][] edges;
    private ArrayList vertexList;
    private boolean[] isVisited;
    private int numVertex;

    public Graph(int n) {
        edges = new int[n][n];
        vertexList = new ArrayList(n);
        isVisited = new boolean[n];
        numVertex = n;





        // 每个顶点初始化为false
        for (int i = 0; i < n; i++) {
            isVisited[i] = false;
        }
    }

    public void insertVertex(String vertex) {
        vertexList.add(vertex);
    }

    public void insertEdge(int v1, int v2, int weight) {
        edges[v1][v2] = weight;
    }

    public void depthFirstSearch() {
        for (int i = 0; i < numVertex; i++) {
            if (!isVisited[i])// 如果某个点没访问的话，那么去遍历
            {
                depthFirstSearch(isVisited, i);
            }
        }
    }

    public int getFirstNeighbor(int index) {
        for (int j = 0; j < numVertex; j++) {
            if (edges[index][j] > 0) {
                return j;
            }
        }
        return -1;// 表示此点没有与之相邻的点
    }

    // 从v2开始检查，可以减少计算量
    public int getNextNeighbor(int v1, int v2) {
        for (int j = v2 + 1; j < numVertex; j++) {
            if (edges[v1][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    public void depthFirstSearch(boolean[] isVisited, int i) {
        //
        System.out.print(vertexList.get(i) + " ");
        isVisited[i] = true;
        int newStartNode = getFirstNeighbor(i);
        while (newStartNode != -1) {
            if (!isVisited[newStartNode])// 如果这个点没有被访问
            {
                depthFirstSearch(isVisited, newStartNode);
            }
            newStartNode = getNextNeighbor(i, newStartNode);
        }
    }

    // 广度优先
    public void broadFirstSearch() {
        for (int i = 0; i < numVertex; i++) {
            broadFirstSearch(isVisited, i);
        }
    }

    private void broadFirstSearch(boolean[] isVisited, int i) {
        int currentVisitedNode, adjacentCurrentVisitedNode;
        LinkedList queue = new LinkedList();
        // 访问该节点
        System.out.print(vertexList.get(i) + " ");
        isVisited[i] = true;
        // 节点入队列
        queue.add(i);
        while (!queue.isEmpty()) {
            currentVisitedNode = ((Integer) queue.removeFirst()).intValue();// 移除队列的第一个元素，即头
            adjacentCurrentVisitedNode = getFirstNeighbor(currentVisitedNode);

            while (adjacentCurrentVisitedNode != -1) {
                if (!isVisited[adjacentCurrentVisitedNode]) {
                    // 访问该节点
                    System.out.print(vertexList.get(adjacentCurrentVisitedNode) + " ");
                    // 标记该节点
                    isVisited[adjacentCurrentVisitedNode] = true;
                    // 入队列
                    queue.addLast(adjacentCurrentVisitedNode);
                }
                // 寻找下一个邻接节点
                adjacentCurrentVisitedNode = getNextNeighbor(currentVisitedNode, adjacentCurrentVisitedNode);
            }
        }

    }
}

package test;

public class TestSearch {
    public static void main(String args[]) {

        String labels[] = { "1", "2", "3", "4", "5" };// 结点的标识
        int n = labels.length;
        Graph graph = new Graph(n);
        for (String label : labels) {
            graph.insertVertex(label);// 插入结点
        }
        // 插入四条边
        graph.insertEdge(0, 1, 1);
        graph.insertEdge(0, 2, 1);
        graph.insertEdge(1, 3, 1);
        graph.insertEdge(1, 4, 1);

        System.out.println("深度优先搜索序列为：");
        graph.depthFirstSearch();
        
         System.out.println();
         System.out.println("广度优先搜索序列为：");
         graph.broadFirstSearch();
    }
}

运行结果如下：

深度优先搜索序列为：
1 2 4 5 3
广度优先搜索序列为：
1 2 3 4 5

总的来说，BFS多用于寻找最短路径的问题，DFS多用于快速发现底部节点。

DFS的思想是从一个顶点V0开始，沿着一条路一直走到底，如果发现不能到达目标解，那就返回到上一个节点，然后从另一条路开始走到底。

DFS适合此类题目：给定初始状态跟目标状态，要求判断从初始状态到目标状态是否有解。

深度与广度的比较：

我们搜索一个图是按照树的层次来搜索的。

我们假设一个节点衍生出来的相邻节点平均的个数是N个，那么当起点开始搜索的时候，队列有一个节点，当起点拿出来后，把它相邻的节点放进去，那么队列就有N个节点，当下一层

的搜索中再加入元素到队列的时候，节点数达到了N/2，你可以想象，一旦N是一个比较大的数的时候，这个树的层次又比较深，那这个队列就需要很大的内存空间了。

于是广度优先搜索的缺点出来了：在树的层次较深或子节点数较多的情况下，消耗内存十分严重。广度优先搜索适用于节点的子节点数量不多，并且树的层次不会太深的情况。

那么深度优先就可以克服这个缺点，因为每次搜的过程，每一层只需维护一个节点。但回过头想想，广度优先能够找到最短路径，那深度优先能否找到呢？深度优先的方法是一条路走到黑，

那显然无法知道这条路是不是最短的，所以你还得继续走别的路去判断是否是最短路？

于是深度优先搜索的缺点也出来了：难以寻找最优解，只能寻找有解。其优点就是内存消耗小，克服了刚刚说的广度优先搜索的缺点。

递归版深度优先

public class DFSTest
{
    private int vertexNum;//顶点个数
    private int[][] adjacent;//邻接矩阵
    private boolean[] isVisited;//顶点是否经过的标记
    private char[] nodeName;//顶点名称
    
    //图的初始化
    public DFSTest(int n)
    {
        vertexNum=n;
        adjacent=new int[vertexNum][vertexNum];
        isVisited=new boolean[vertexNum];
        for (int i=0;i<vertexNum;i++)
        {
            for (int j=0;j<vertexNum;j++)
            {
                adjacent[i][j]=0;
            }
        }
        
        for (int k=0;k<n;k++)
        {
            isVisited[k]=false;
        }
    }
    
    public void setNodeName(char[] a)
    {
        nodeName=new char[vertexNum];
        for (int i=0;i<a.length;i++)
        {
            nodeName[i]=a[i];
        }
    }
    
    //无向图
    public void setAdjacent(int i,int j)
    {
        adjacent[i][j]=1;
        adjacent[j][i]=1;
    }
    
    
    
    //遍历
    public void dfsTraverse()
    {
        for (int i=0;i<vertexNum;i++)
        {
            if (isVisited[i]==false)
            {
                dfs(i);
            }
        }
    }
    
    public void dfs(int n)
    {
        isVisited[n]=true;//
        //可利用每次遍历的节点的个数来判断此路是否有解
        System.out.println(nodeName[n]);
        for (int i=0;i<vertexNum;i++)
        {
            if (adjacent[n][i]==1&&isVisited[i]==false)
            {
                dfs(i);
            }
        }
    }
    
    
    public static void main(String[] args)
    {
        int n=4;//表示图中顶点的个数
        DFSTest dfsTest=new DFSTest(n);
        //给顶点赋名字
        char[] name={'A','B','C','D'};
        dfsTest.setNodeName(name);
        //加边
        dfsTest.setAdjacent(0, 1);
        dfsTest.setAdjacent(1, 3);
        dfsTest.setAdjacent(2, 3);
        
        dfsTest.dfsTraverse();
        
    }
}