並查集的應用之求解無向圖中的連接分量個數

一，介紹

本文使用數據結構：並查集 來實現 求解無向圖的連通分量個數。

無向圖的連通分量就是：無向圖的一個極大連通子圖，在極大連通子圖中任意兩個頂點之間一定存在一條路徑。對於連通的無向圖而言，只有一個連通分量。

 

二，構造一個簡單的無向圖

這里僅演示求解無向圖的連通分量，因此需要先構造一個無向圖。圖由頂點和邊組成，並采用圖的鄰接表形式存儲。頂點類和邊類的定義如下：

    private class Vertex{
        private Integer vertexLabel;
        private List<Edge> adjEdges;//鄰接表
        public Vertex(Integer vertexLabel) {
            this.vertexLabel = vertexLabel;
            adjEdges = new LinkedList<ConnectedComponents.Edge>();
        }
    }
    
    private class Edge{
        private Vertex endVertex;
        public Edge(Vertex v) {
            this.endVertex = v;
        }
    }

 

然后，再使用一個Map來存儲圖中的頂點。Map的Key為頂點的標識，Value為Vertex頂點對象。關於如何定義一個圖，可參考。

private Map<String, Vertex> nondirectedGraph;

 

三，求解無向圖的連通分量的思路

首先需要一個一維數組來存儲並查集。這里一維數組的下標表示圖的頂點標識，數組元素s[i]有兩種表示含義：當數組元素大於0時，表示的是 頂點 i 的父結點位置 ；當數組元素s[i]小於0時，表示的是 頂點 i 為根的子樹的高度(秩！)。從而將數組的下標與圖的頂點一 一 對應起來。

    private int[] s;
    private int tree_numbers;//並查集中子樹的棵數

 

求解連通的分量的總體思路如下：

①構造一個圖。或者說得先有一個圖

②根據圖中的每一個頂點，初始化並查集。也就是對於每個頂點，構造一棵只有一個頂點的子樹(並查集的子樹)。

③對於圖中的每一條邊，這條邊一定關聯了兩個頂點，檢查這兩個頂點是否在同一個子集合中，如果不在，則執行union操作將這兩個頂點合並到同一個集合中

④當遍歷完所有的邊之后，並查集中子樹的個數即為連通分量的個數

偽代碼如下：

CONNECTED-COMPONENTS(G)
    for each vertex v belongs to V(G)
          do MAKE-SET(v)
    for each edge(u,v) belongs to E(G)
           do if FIND(u) != FIND(v)
                then UNION(u,v)

 

四，代碼分析及實現

關於並查集的理解參考這篇文章：數據結構--並查集的原理及實現

 為方便起見，這里假設頂點的標識從0開始的字符串類型的連續的數字，如 0，1，2，3，4.......

make_set方法初始化並查集

    private void make_set(Map<String, Vertex> graph){
        int size = graph.size();//頂點的個數
        s = new int[size];
        for(Vertex v : graph.values()){
            s[Integer.valueOf(v.vertexLabel)] = -1;//頂點的標識是從0開始連續的數字
        }
        
        tree_numbers = size;//初始時,一共有 |V| 個子樹 
    }

s數組是並查集的存儲結構，第2行獲取圖中頂點的個數，構造並查集數組。其中，數組的下標表示圖中頂點的標識，數組元素s[i]有兩種表示含義：當數組元素大於0時，表示的是 頂點 i 的父結點位置 ；當數組元素s[i]小於0時，表示的是 頂點 i 為根的子樹的高度(秩！)

由於約定了頂點的標識為0,1,2,3.....故第5行根據圖中每個頂點來構造一棵單節點的樹。

假設無向圖如下：頂點的標識為 0,1,2,3,4,5,6

構造初始並查集后，s數組內容如下：

 

union操作

    private void union(int root1, int root2) {
        if (find(root1) == find(root2))
            return;
        //union中的參數是合並任意兩個頂點,但是對於並查集,合並的對象是該頂點所在集合的代表頂點(根頂點)
        root1 = find(root1);//查找頂點root1所在的子樹的根
        root2 = find(root2);//查找頂點root2所在的子樹的根
        
        if (s[root2] < s[root1])// root2 is deeper
            s[root1] = root2;
        else {
            if (s[root1] == s[root2])// 一樣高
                s[root1]--;// 合並得到的新的子樹高度增1 (以root1作為新的子樹的根)
            s[root2] = root1;// root1 is deeper
        }
        tree_numbers--;// 合並后,子樹的數目減少1
    }

注意第5、6行。union操作的對象應該是子樹的樹根。因為，union時使用了按秩求並，使用的是子樹的根結點的秩。

否則的話，程序將會有bug---求出錯誤的連通分量個數。

 

求解連通分量的代碼如下：

public int connectedComponents(Map<String, Vertex> graph) {
        for (Vertex v : graph.values()) {
            int startLabel = Integer.valueOf(v.vertexLabel);

            List<Edge> edgeList = v.adjEdges;
            for (Edge e : edgeList) {
                Vertex end = e.endVertex;// 獲得該邊的終點
                int endLabel = Integer.valueOf(end.vertexLabel);

                if (find(startLabel) != find(endLabel))
                    union(startLabel, endLabel);//這兩個頂點不在同一個子樹中,需要union
            }
        }
        return tree_numbers;
    }

 第5行，遍歷圖中的每一條邊。第10行，對該邊關聯的兩個頂點進行判斷：這兩個頂點是否已經連通了(在同一棵子樹中了)

求解連通分量時，對圖中的每個頂點和每條邊都進行了一次遍歷，故算法的時間復雜度為O(V+E)

 

五，整個完整代碼

import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import c9.topo.FileUtil;

public class ConnectedComponents {
    private class Vertex {
        private String vertexLabel;
        private List<Edge> adjEdges;// 鄰接表

        public Vertex(String vertexLabel) {
            this.vertexLabel = vertexLabel;
            adjEdges = new LinkedList<ConnectedComponents.Edge>();
        }
    }

    private class Edge {
        private Vertex endVertex;

        public Edge(Vertex v) {
            this.endVertex = v;
        }
    }

    private Map<String, Vertex> nonDirectedGraph;

    public ConnectedComponents(String graphContent) {
        nonDirectedGraph = new LinkedHashMap<String, ConnectedComponents.Vertex>();

        buildGraph(graphContent);

        make_set(nonDirectedGraph);// 初始化並查集
    }

    private void buildGraph(String graphContent){
        String[] lines = graphContent.split("\n");
        
        String startNodeLabel, endNodeLabel;
        Vertex startNode, endNode;
        for(int i = 0; i < lines.length; i++){
            if(lines[i].length()==1)//某行只有一個頂點
            {
                startNodeLabel = lines[i];
                nonDirectedGraph.put(startNodeLabel, new Vertex(startNodeLabel));
                continue;
            }
            String[] nodesInfo = lines[i].split(",");
            startNodeLabel = nodesInfo[0];
            endNodeLabel = nodesInfo[1];
            
            endNode = nonDirectedGraph.get(endNodeLabel);
            if(endNode == null){
                endNode = new Vertex(endNodeLabel);
                nonDirectedGraph.put(endNodeLabel, endNode);
            }
            
            startNode = nonDirectedGraph.get(startNodeLabel);
            if(startNode == null){
                startNode = new Vertex(startNodeLabel);
                nonDirectedGraph.put(startNodeLabel, startNode);
            }
            Edge e = new Edge(endNode);
            //對於無向圖而言,起點和終點都要添加邊
            endNode.adjEdges.add(e);
            startNode.adjEdges.add(e);
        }
    }

    private int[] s;
    private int tree_numbers;

    private void make_set(Map<String, Vertex> graph) {
        int size = graph.size();
        s = new int[size];
        for (Vertex v : graph.values()) {
            s[Integer.valueOf(v.vertexLabel)] = -1;// 頂點的標識是從0開始連續的數字
        }

        tree_numbers = size;// 初始時,一共有 |V| 個子樹
    }

    private void union(int root1, int root2) {
        if (find(root1) == find(root2))
            return;
        //union中的參數是合並任意兩個頂點,但是對於並查集,合並的對象是該頂點所在集合的代表頂點(根頂點)
        root1 = find(root1);//查找頂點root1所在的子樹的根
        root2 = find(root2);//查找頂點root2所在的子樹的根
        
        if (s[root2] < s[root1])// root2 is deeper
            s[root1] = root2;
        else {
            if (s[root1] == s[root2])// 一樣高
                s[root1]--;// 合並得到的新的子樹高度增1 (以root1作為新的子樹的根)
            s[root2] = root1;// root1 is deeper
        }
        tree_numbers--;// 合並后,子樹的數目減少1
    }

    private int find(int root) {
        if (s[root] < 0)
            return root;
        else
            return s[root] = find(s[root]);
    }

    public int connectedComponents(Map<String, Vertex> graph) {
        for (Vertex v : graph.values()) {
            int startLabel = Integer.valueOf(v.vertexLabel);

            List<Edge> edgeList = v.adjEdges;
            for (Edge e : edgeList) {
                Vertex end = e.endVertex;// 獲得該邊的終點
                int endLabel = Integer.valueOf(end.vertexLabel);

                if (find(startLabel) != find(endLabel))
                    union(startLabel, endLabel);
            }
        }
        return tree_numbers;
    }

    // for test purposes
    public static void main(String[] args) {
        String graphFilePath;
        if (args.length == 0)
            graphFilePath = "F:\\graph.txt";
        else
            graphFilePath = args[0];

        String graphContent = FileUtil.read(graphFilePath, null);// 從文件中讀取圖的數據
        ConnectedComponents cc = new ConnectedComponents(graphContent);
        int count = cc.connectedComponents(cc.nonDirectedGraph);
        System.out.println("連通分量個數:" + count);
    }
}

FileUtil類可參考中的完整代碼實現。

 

六，測試

文件格式如下：

第一列表示起始頂點的標識，第二列表示終點的標識。若沒有邊，則一行中只有一個頂點。

生成的圖如下：

整個程序運行完成后，並查集數組內容如下：

 

結果如下：