博主按：因爲教程所示圖片使用的是 github 倉庫圖片，網速過慢的朋友請移步《並查集：集合合併與元素查找》原文地址。更歡迎來我的小站看更多原創內容：godbmw.com，進行“姿勢”交流 ♪(^∇^*)
1. 什麼時候需要並查集？
在一些有 N 個元素的集合應用問題中，我們通常是在開始時讓每個元素構成一個單元素的集合，然後按一定順序將屬於同一組的元素所在的集合合併，其間要反覆查找一個元素在哪個集合中。
這個過程就涉及到：“合併”和“查找”這兩個操作。
利用並查集，可以實現用數組存儲數據，並且查找操作和合並操作的時間複雜度近乎$O(1)$。
2. 如何實現並查集？
2.1 實現查找操作
並查集是一種樹形數據結構。在這些數據中，每個集合是一棵樹，所有的集合在一起就形成了“森林”。
當然，之前說過要節省空間，藉助數組就可以實現。爲了方便說明，這裏數組的索引值就是數據本身，而索引 i 對應的數組的值arr[i]就是i的根節點。
如下圖所示。3、4、9 這三個元素都以 8 位根節點。此時判斷兩個元素是否屬於同一集合，只需要遞歸找到元素的根節點，比較根節點是否相同即可。
2.2 實現合併操作
這裏的“合併”是指：將兩個元素所在的集合合併爲一個集合。
這一步操作實現邏輯較複雜，假設有兩個元素 p 和 q 需要合併到一個集合，思路如下：
- 查找 p 和 q 的根節點，如果相同，兩個元素已經是同一集合，跳出程序。如果不相同，往下執行。
- 將其中一個根節點的重新指向另一個跟節點，完成集合合併操作。
3. 算法分析和優化
前面已經說了，“並查集”是一種樹形數據結構。而我們的查找和合並操作其實都是建立在從葉節點向上遞歸查找根節點的操作上。
因此，“並查集”的時間複雜度和樹的深度有關，下面的優化操作也是爲了讓樹的深度儘可能少，甚至變成 1 或者 2 層。
3.1 合併優化
如2.2所陳述，這步操作： “將其中一個根節點的重新指向另一個跟節點，完成集合合併操作” ，其實可能會造成樹的高度增加。例如下圖兩棵樹：
如果是右邊那棵樹的根節點指向了左邊樹的根節點，那麼，新形成的樹的高度就是 4。然而，左邊那棵樹的根節點如果指向右邊那棵樹的跟節點，樹的高度就是 3。如此一來，形成的樹的高度更低。
優化的方法就是：在“合併操作”的更改根節點指向的這步中，檢測兩棵樹的高度，將高度較低的那顆樹指向高度較高的樹的根節點。所以，在初始化的時候，需要多一個數組rank[]，用來記錄以 i 爲根節點的樹的高度。
3.2 “路徑壓縮”
大名鼎鼎的路徑壓縮，就是在“查找”的過程中，將樹的高度壓縮成 2 層。如果對元素p調用了一次查找操作，那麼以p爲葉子節點的往上一直到根節點的所有節點，都會被壓縮。
如下圖所示，在執行find(4)操作後，整棵樹的樣子就變成了圖右邊的樣子。
代碼的實現，需要藉助遞歸，請直接看find()方法。
4. 代碼實現
關於並查集的數據結構封裝在了頭文件union_find.h中：
// union_find.h
// Created by godbmw.com on 2018/10/9.
//
#ifndef UNIONFIND_UNION_FIND_H
#define UNIONFIND_UNION_FIND_H
#include <iostream>
#include <cassert>
using namespace std;
class UnionFind {
private:
int count;
// parent[i]：元素i父節點的索引值
int *parent;
// rank[i]：以i爲根的集合所表示的樹的層數
int *rank;
public:
UnionFind(int count) {
this->count = count;
parent = new int[count];
rank = new int[count];
// 每個節點都是獨立的，所以父節點索引就是自己
// 每個節點的樹的高度都是1
for(int i = 0; i < count; i++) {
parent[i] = i;
rank[i] = 1;
}
}
~UnionFind() {
delete[] parent;
delete[] rank;
}
// 查找索引爲p的元素的根節點的索引
int find(int p) {
// 路徑壓縮：將層數爲n( n>1 )的樹壓縮爲層數爲1的樹
if( p != this->parent[p]) {
this->parent[p] = this->find( this->parent[p] );
}
return parent[p];
}
// 查看索引分別爲p和q的元素是否屬於同一集合
bool is_connected(int p, int q) {
return this->find(p) == this->find(q);
}
// 合併索引分別p和q的元素到一個集合
void union_elements(int p, int q) {
int p_root = this->find(p), q_root = this->find(q);
// 根節點索引值相同：已經屬於同一集合
if(p_root == q_root) return ;
if( this->rank[p_root] < this->rank[q_root] ) {
// 合併後，q_root 的樹的深度並沒有改變
this->parent[p_root] = q_root;
} else if ( this->rank[q_root] < this->rank[p_root] ) {
// 合併後，p_root 的樹的深度並沒有改變
this->parent[q_root] = p_root;
} else {
// 合併後，q_root 的深度加 1
this->parent[p_root] = q_root;
this->rank[q_root] += 1;
}
}
};
#endif //UNIONFIND_UNION_FIND_H5. 代碼測試
直接上了 1 億的數據量，並且執行了 1 一次合併操作和 1 億次檢查是否屬於同一集合的操作。在我的電腦上耗時基本是 8s。有圖有真相：
測試代碼main.cpp如下：
// main.cpp
// created by godbmw.com
#include <iostream>
#include <ctime>
#include "union_find.h"
#define N 100000000
using namespace std;
void calc_run_time() {
srand(time(NULL));
register int a, b;
UnionFind uf = UnionFind(N);
time_t start_time = clock();
for(int i = 0; i < N; i++) {
a = rand() % N;
b = rand() % N;
uf.union_elements(a, b);
}
for(int i = 0; i < N; i++) {
a = rand() % N;
b = rand() % N;
uf.is_connected(a, b);
}
time_t end_time = clock();
cout << double(end_time - start_time) / CLOCKS_PER_SEC<<" s"<<endl;
}
int main() {
calc_run_time();
return 0;
}