不相交集合数据结构保持一组不相交的动态集合S={S1，S2，...,SK},每个集合通过一个代表来识别，代表即集合中的某个成员。
如果x表示一个对象，不相交集合支持以下操作：
MAKE-SET(x):建立一个新的集合，其唯一成员为x。因为各集合是不想交的，故x没有在其它集合中出现。
UNION(x,y):将包含x和包含y的集合合并为一个新的集合。
FIND-SET(x):返回包含x的集合。
1.不相交集合的数组表示在一个数组中保存每个元素所在集合的名称。这样Find操作就是简单的O(1)查找。要执行Union(x,y)操作，假设x在等价类i中，y在等价类j中，
扫描整个数组，将所有的i变为j。连续N-1次Union操作就要花费Θ(N2)的时间。如果Union操作很多，这个界是不可接受的。
2.不相交集合的链表表示每一个集合用用一个链表来表示。链表的第一个对象作为它所在集合的代表。链表中每个对象都包含一个集合成员，一个指向下一个对象的指针，
以及指向代表的指针。每个链表含head和tail指针，head指向链表的代表，tail指向链表中最后的对象。
Union的简单实现：将x所在的链表拼接到y所在链表的表尾。对于原先x所在链表中的每一个对象都要更新其指向代表的指针。
平均看来，每个操作需要Θ(N)的时间。
加权合并：每个表含表的长度，总是将更短的表连接到长的表的后面。这样，m和MAKE-SET,UNION和FIND-SET操作要花费(m+nlgn)的时间。
class SetNode(object):
def __init__(self,key):
self.key=key
self.next=None
self.rep=None
class SetEntry(object):
def __init__(self):
self.head=None
self.tail=None
self.len=0
class DisjSet(object):
def __init__(self,node):
self.setlist=[]
def make_set(self,node):
S=SetEntry()
S.head=node
S.tail=node
S.len=1
node.rep=node
self.setlist.append(S)
def find(self,node):
return node.rep
def union(self,node_x,node_y):
rep_x=node_x.rep
rep_y=node_y.rep
if rep_x!=rep_y:
for s in self.setlist:
if s.head==rep_x:
set_x=s
elif s.head==rep_y:
set_y=s
if set_x.len>=set_y.len:
set_x.tail.next=rep_y
node=rep_y
while node is not None:
node.rep=rep_x
node=node.next
set_x.tail=set_y.tail
set_x.len=set_x.len+set_y.len
self.setlist.remove(set_y)
return rep_x
else:
set_y.tail.next=rep_x
node=rep_x
while node is not None:
node.rep=rep_y
node=node.next
set_y.tail=set_x.tail
set_y.len+=set_x.len
self.setlist.remove(set_x)
return rep_y
3.不相交集合森林使用树来表示一个集合，树的根用来作为集合的代表。树的每个节点都含有元素的数据以及一个指向父节点的指针。根节点的指针为空。
可以用数组来非显式的来表示树：数组的每个成员T[i]表示元素i的父节点，如果i是根，取p[i]为0或者-1。
如果任意执行Union操作，树可能会变为退化树，有几种方法可以避免这种情况
3.1 灵巧求并算法
总是让更小的树成为较大的树的子树，称为按大小求并。另一种方法是按高度求并。
这样的话，任何节点的深度都不会超过logN，Find操作的运行时间是O(logN),而连续M次操作则花费O(MlogN)。
实现时，让数组每个元素包含它的树的大小的负值。
class DisjSet(object):
def __init__(self,size):
self.list=[-1]*size
def find(self,x):
if self.list[x]<0:
return x
else:
return self.find(self.list[x])
def union(self,x,y):
set_x=self.find(x)
set_y=self.find(y)
if set_x!=set_y:
if self.list[set_x]>self.list[set_y]:
self.list[set_y]+=self.list[set_x]
self.list[set_x]=set_y
return set_y
else:
self.list[set_x]+=self.list[set_y]
self.list[set_y]=set_x
return set_x
3.2 路径压缩
路径压缩在一次Find(X)操作期间执行，从X到根的路径上的每一个节点都使它的父节点变成根。
路径压缩与按大小求并是完全兼容的，而不完全与按高度求并兼容。路径压缩时每棵树的高度会发生变化，可以对每棵树所存储的高度估计，用秩rank表示。
class DisjSet_with_rank(object):
def __init__(self,size):
self.list=[-1]*size
def find(self,x):
if self.list[x]<0:
return x
else:
self.list[x]=self.find(self.list[x])
return self.list[x]
def union(self,x,y):
set_x=self.find(x)
set_y=self.find(y)
if set_x!=set_y:
if self.list[set_x]<self.list[set_y]:
self.list[set_y]=set_x
else:
if self.list[set_x]==self.list[set_y]:
self.list[set_y]-=1
self.list[set_x]=set_y
路径压缩的显式表示
class SetNode(object):
def __init__(self,key):
self.parent=None
self.key=key
self.rank=1
def find(node):
if node.parent is None:
return node
else:
node.parent=find(node.parent)
return node.parent
def union(x,y):
x=find(x)
y=find(y)
if x!=y:
if x.rank<=y.rank:
if x.rank==y.rank:
y.rank+=1
x.parent=y
return y
else:
y.parent=x
return x