图的广度,深度搜索_图的广度搜索-优快云博客

本文深入探讨了图数据结构的创建过程，包括顶点与边的管理，以及深度优先搜索（DFS）和广度优先搜索（BFS）算法的实现细节。通过具体代码示例，读者可以理解如何遍历图中的所有顶点，查找连通组件，并掌握DFS和BFS在实际应用中的操作流程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

//图类的创建
public class Graph {
    //顶点数
   private final int V;
   //边的总数
   private int Lines;
   private ArrayList<ArrayList<Integer>> table;
    public Graph(int v) {
        V = v;
        Lines=0;
        table= new ArrayList<ArrayList<Integer>>();
        for (int i = 0; i <v ; i++) {
            table.add(new ArrayList<Integer>());
        }

    }

    public int getV() {
        return V;
    }

    public int getLines() {
        return Lines;
    }
    public void addEdge(int m,int n){
        table.get(m).add(n);
        table.get(n).add(m);
        Lines++;

    }
    public ArrayList<Integer> RelatedV(int v){
        return table.get(v);
    }

}
//深度搜索
public class DepthFirst {
    public boolean[] marked;
    private int count;//查找所有与该点相通的点
    public DepthFirst(Graph G,int goal){
        marked = new boolean[G.getV()];
        count=0;
       df(G, goal);
    }
    private void df(Graph G,int goal){
        marked[goal]=true;
        for (Integer m: G.RelatedV(goal)) {  //八皇后路径问题,有for才有多条路径因为for存在才会有反向回溯,没for最多只有一条
            if (marked[m]==false){
                df(G, m);
            }
        }
        count++;  //count++的位置值得想想
    }
    //判断是否与当前节点连通
    public boolean marked(int x){
        return marked[x];
    }

    public int getCount() {
        return count;
    }
}
//广度
public class WidthFirst {
    boolean[] marked;
    int count;
    LinkedList<Integer> waitSearch;
    public WidthFirst(Graph g,int goal){
        marked=new boolean[g.getV()];
        count=0;
        waitSearch=new LinkedList<Integer>();
        WidthFirstSearch(g, goal);
    }
    public void WidthFirstSearch(Graph g,int flag){

//              waitSearch.addFirst(flag);
//        while (!waitSearch.isEmpty()){
//            Integer head = waitSearch.removeFirst();
//            if (marked[head]==false){
//                System.out.print(head+"->");
//                marked[head]=true;
//                count++;
//            }
//            ArrayList<Integer> list = g.RelatedV(head);
//            for (int i = 0; i < list.size() ; i++) {
//                if (marked[list.get(i)]==false) {
//                    waitSearch.addLast(list.get(i));
//                  //  marked[list.get(i)]=true;    要么进队的时候设置,要么出队设置,不要弄混淆,否则这个数永远都不会被打印
//                }
//            }
//        }
        waitSearch.addLast(flag);
        while (!waitSearch.isEmpty()){
            Integer first = waitSearch.removeFirst();
              if (marked[first]==false){
                  marked[first]=true;
                  count++;
              }
            ArrayList<Integer> list = g.RelatedV(first);
            for (int i = 0; i <list.size() ; i++) {
                Integer content = list.get(i);
                if (marked[content]==false){
                    waitSearch.addLast(content);
                }
            }
        }

    }
    public boolean remarked(int x){
        return marked[x];
    }
}