並查集

並查集（Union-find Sets）是一種非常精巧而實用的數據結構，它主要用於處理一些不相交集合的合並問題。一些常見的用途有求連通子圖、求最小生成樹的 Kruskal 算法和求最近公共祖先（Least Common Ancestors, LCA）等。

使用並查集時，首先會存在一組不相交的動態集合 $S = \left\{ {{S_1},{S_2}, \cdots ,{S_k}} \right\}$，一般都會使用一個整數表示集合中的一個元素。

每個集合可能包含一個或多個元素，並選出集合中的某個元素作為代表。每個集合中具體包含了哪些元素是不關心的，具體選擇哪個元素作為代表一般也是不關心的。我們關心的是，對於給定的元素，可以很快的找到這個元素所在的集合（的代表），以及合並兩個元素所在的集合，而且這些操作的時間復雜度都是常數級的。

並查集的基本操作有三個：

1. makeSet(s)：建立一個新的並查集，其中包含 s 個單元素集合。
2. unionSet(x, y)：把元素 x 和元素 y 所在的集合合並，要求 x 和 y 所在的集合不相交，如果相交則不合並。
3. find(x)：找到元素 x 所在的集合的代表，該操作也可以用於判斷兩個元素是否位於同一個集合，只要將它們各自的代表比較一下就可以了。

並查集的實現原理也比較簡單，就是使用樹來表示集合，樹的每個節點就表示集合中的一個元素，樹根對應的元素就是該集合的代表，如圖 1 所示。

圖 1 並查集的樹表示

圖中有兩棵樹，分別對應兩個集合，其中第一個集合為 $\left\{ a, b, c, d \right\}$，代表元素是 $a$；第二個集合為 $\left\{ e, f, g \right\}$，代表元素是 $e$。

樹的節點表示集合中的元素，指針表示指向父節點的指針，根節點的指針指向自己，表示其沒有父節點。沿着每個節點的父節點不斷向上查找，最終就可以找到該樹的根節點，即該集合的代表元素。

現在，應該可以很容易的寫出 makeSet 和 find 的代碼了，假設使用一個足夠長的數組來存儲樹節點（很類似之前講到的靜態鏈表），那么 makeSet 要做的就是構造出如圖 2 的森林，其中每個元素都是一個單元素集合，即父節點是其自身：

圖 2 構造並查集初始化

相應的代碼如下所示，時間復雜度是 $O(n)$：

const int MAXSIZE = 500;
int uset[MAXSIZE];

void makeSet(int size) {
	for(int i = 0;i < size;i++) uset[i] = i;
}

接下來，就是 find 操作了，如果每次都沿着父節點向上查找，那時間復雜度就是樹的高度，完全不可能達到常數級。這里需要應用一種非常簡單而有效的策略——路徑壓縮。

路徑壓縮，就是在每次查找時，令查找路徑上的每個節點都直接指向根節點，如圖 3 所示。

圖 3 路徑壓縮

我准備了兩個版本的 find 操作實現，分別是遞歸版和非遞歸版，不過兩個版本目前並沒有發現有什么明顯的效率差距，所以具體使用哪個完全憑個人喜好了。

int find(int x) {
	if (x != uset[x]) uset[x] = find(uset[x]);
	return uset[x];
}
int find(int x) {
	int p = x, t;
	while (uset[p] != p) p = uset[p];
	while (x != p) { t = uset[x]; uset[x] = p; x = t; }
	return x;
}

最后是合並操作 unionSet，並查集的合並也非常簡單，就是將一個集合的樹根指向另一個集合的樹根，如圖 4 所示。

圖 4 並查集的合並

這里也可以應用一個簡單的啟發式策略——按秩合並。該方法使用秩來表示樹高度的上界，在合並時，總是將具有較小秩的樹根指向具有較大秩的樹根。簡單的說，就是總是將比較矮的樹作為子樹，添加到較高的樹中。為了保存秩，需要額外使用一個與 uset 同長度的數組，並將所有元素都初始化為 0。

void unionSet(int x, int y) {
	if ((x = find(x)) == (y = find(y))) return;
	if (rank[x] > rank[y]) uset[y] = x;
	else {
		uset[x] = y;
		if (rank[x] == rank[y]) rank[y]++;
	}
}

下面是按秩合並的並查集的完整代碼，這里只包含了遞歸的 find 操作。

const int MAXSIZE = 500;
int uset[MAXSIZE];
int rank[MAXSIZE];

void makeSet(int size) {
	for(int i = 0;i < size;i++)  uset[i] = i;
	for(int i = 0;i < size;i++)  rank[i] = 0;
}
int find(int x) {
	if (x != uset[x]) uset[x] = find(uset[x]);
	return uset[x];
}
void unionSet(int x, int y) {
	if ((x = find(x)) == (y = find(y))) return;
	if (rank[x] > rank[y]) uset[y] = x;
	else {
		uset[x] = y;
		if (rank[x] == rank[y]) rank[y]++;
	}
}

除了按秩合並，並查集還有一種常見的策略，就是按集合中包含的元素個數（或者說樹中的節點數）合並，將包含節點較少的樹根，指向包含節點較多的樹根。這個策略與按秩合並的策略類似，同樣可以提升並查集的運行速度，而且省去了額外的 rank 數組。

這樣的並查集具有一個略微不同的定義，即若 uset 的值是正數，則表示該元素的父節點（的索引）；若是負數，則表示該元素是所在集合的代表（即樹根），而且值的相反數即為集合中的元素個數。相應的代碼如下所示，同樣包含遞歸和非遞歸的 find 操作：

const int MAXSIZE = 500;
int uset[MAXSIZE];

void makeSet(int size) {
	for(int i = 0;i < size;i++) uset[i] = -1;
}
int find(int x) {
	if (uset[x] < 0) return x;
	uset[x] = find(uset[x]);
	return uset[x];
}
int find(int x) {
	int p = x, t;
	while (uset[p] >= 0) p = uset[p];
	while (x != p) {
		t = uset[x];
		uset[x] = p;
		x = t;
	}
	return x;
}
void unionSet(int x, int y) {
	if ((x = find(x)) == (y = find(y))) return;
	if (uset[x] < uset[y]) {
		uset[x] += uset[y];
		uset[y] = x;
	} else {
		uset[y] += uset[x];
		uset[x] = y;
	}
}

如果要獲取某個元素 x 所在集合包含的元素個數，可以使用 -uset[find(x)] 得到。

並查集的空間復雜度是 $O(n)$ 的，這個很顯然，如果是按秩合並的，占的空間要多一些。find 和 unionSet 操作都可以看成是常數級的，或者准確來說，在一個包含 $n$ 個元素的並查集中，進行 $m$ 次查找或合並操作，最壞情況下所需的時間為 $O\left( {m\alpha (n)} \right)$，這里的 $\alpha$ 是 Ackerman 函數的某個反函數，在極大的范圍內（比可觀察到的宇宙中估計的原子數量 $10^{80}$ 還大很多）都可以認為是不大於 4 的。具體的時間復雜度分析，請參見《算法導論》的 21.4 節 帶路徑壓縮的按秩合並的分析。