博主按：因為教程所示圖片使用的是 github 倉庫圖片，網速過慢的朋友請移步《并查集：集合合并與元素查找》原文地址。更歡迎來我的小站看更多原創內容：godbmw.com，進行“姿勢”交流 ?(?*)
1. 什么時候需要并查集？
在一些有 N 個元素的集合應用問題中，我們通常是在開始時讓每個元素構成一個單元素的集合，然后按一定順序將屬于同一組的元素所在的集合合并，其間要反復查找一個元素在哪個集合中。
這個過程就涉及到：“合并”和“查找”這兩個操作。
利用并查集，可以實現用數組存儲數據，并且查找操作和合并操作的時間復雜度近乎。
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_H
5. 代碼測試
直接上了 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;
}
