并查集及GO实现

并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。

并查集被很多人认为是最简洁而优雅的数据结构之一，主要用于解决一些元素分组的问题。它管理一系列不相交的集合，并支持两种操作：

• 合并（Union）：把两个不相交的集合合并为一个集合。
• 查询（Find）：查询两个元素是否在同一个集合中。

具体引入可以参考：说明

三种主要操作：

Make_Set(x):

建立一个新的集合，其唯一成员就是x，因此这个集合的代表也是x，并查集要求各集合是不相交的，因此要求x没有在其他集合中出现过。

Find_Set(x):

返回能代表x所在集合的节点，通常返回x所在集合的根节点。有递归和非递归两种方法，下面会有讲解。

Union(x, y):

将包含x,y的动态集合合并为一个新的集合。合并两个集合的关键是找到两个集合的根节点，如果两个根节点相同则不用合并；如果不同，则需要合并。

合并时，如果两个集合的秩相同，任选一个根做为父节点，并增加其秩。

秩不同时，让较小秩的集合指向较大秩的集合，这时秩的大小不变。

秩和集合的数目是不一样的，秩表示节点高度的一个商界；集合的数目表示集合中节点的总数。

如图，这是一个树状的结构，要寻找集合的代表元素，只需要一层一层往上访问父节点（图中箭头所指的圆），直达树的根节点（图中橙色的圆）即可。根节点的父节点是它自己。

初始化

int fa[MAXN];
inline void init(int n)
{
    for (int i = 1; i <= n; ++i)
        fa[i] = i;
}

假如有编号为1, 2, 3, ..., n的n个元素，我们用一个数组fa[]来存储每个元素的父节点（因为每个元素有且只有一个父节点，所以这是可行的）。一开始，我们先将它们的父节点设为自己。

查询

int find(int x)
{
    if(fa[x] == x)
        return x;
    else
        return find(fa[x]);
}

我们用递归的写法实现对代表元素的查询：一层一层访问父节点，直至根节点（根节点的标志就是父节点是本身）。要判断两个元素是否属于同一个集合，只需要看它们的根节点是否相同即可。

合并

inline void merge(int i, int j)
{
    fa[find(i)] = find(j);
}

合并操作也是很简单的，先找到两个集合的代表元素，然后将前者的父节点设为后者即可。当然也可以将后者的父节点设为前者，这里暂时不重要。本文末尾会给出一个更合理的比较方法。

路径压缩

只关心一个元素对应的根节点，那我们希望每个元素到根节点的路径尽可能短，最好只需要一步。只要我们在查询的过程中，把沿途的每个节点的父节点都设为根节点即可。下一次再查询时，我们就可以省很多事。这用递归的写法很容易实现：

int find(int x)
{
    if(x == fa[x])
        return x;
    else{
        fa[x] = find(fa[x]);  //父节点设为根节点
        return fa[x];         //返回父节点
    }
}

此外合并时候，应该把简单的树往复杂的树上合并，而不是相反。因为这样合并后，到根节点距离变长的节点个数比较少。

我们用一个数组rank[]记录每个根节点对应的树的深度（如果不是根节点，其rank相当于以它作为根节点的子树的深度）。一开始，把所有元素的rank（秩）设为1。合并时比较两个根节点，把rank较小者往较大者上合并。

路径压缩和按秩合并如果一起使用，时间复杂度接近 O（N）

故优化后：

初始化

inline void init(int n)
{
    for (int i = 1; i <= n; ++i)
    {
        fa[i] = i;
        rank[i] = 1;
    }
}

查找

int find(int x)
{
    if(x == fa[x])
        return x;
    else{
        fa[x] = find(fa[x]);  //父节点设为根节点
        return fa[x];         //返回父节点
    }
}

合并

inline void merge(int i, int j)
{
    int x = find(i), y = find(j);    //先找到两个根节点
    if (rank[x] <= rank[y])
        fa[x] = y;
    else
        fa[y] = x;
    if (rank[x] == rank[y] && x != y)
        rank[y]++;                   //如果深度相同且根节点不同，则新的根节点的深度+1
}

为什么深度相同，新的根节点深度要+1？如下图，我们有两个深度均为2的树，现在要merge(2,5)：

这里把2的父节点设为5，或者把5的父节点设为2，其实没有太大区别。我们选择前者，于是变成这样：

显然树的深度增加了1。另一种合并方式同样会让树的深度+1。

GO版本实现

//并查集实现
type UFSet struct {
    Father []int
    Rank []int
}

func NewUFSet(n int)UFSet{
    father:=make([]int,n)
    rank:=make([]int,n)
    for i:=0;i<n;i++{
        father[i]=i
        rank[i]=0
    }
    return UFSet{
        Father:father,
        Rank:rank,
    }
}
// 路径压缩， 遍历过程中的所有父节点直接指向根节点，
// 减少后续查找次数
func (ds UFSet)Find(x int)int {
    if x==ds.Father[x]{
        return x
    }
    ds.Father[x]=ds.Find(ds.Father[x])//父节点设为根节点，路径压缩
    return ds.Father[x]
}
//合并两个节点
// 如果处于同一个并查集， 不需要合并
// 如果不处于同一个并查集，判断两个rootx和rooty谁的秩大
func (ds UFSet)Merge(x, y int){
    rootX:=ds.Find(x)
    rootY:=ds.Find(y)
    if rootX!=rootY{
        //按rank合并，合并到大的rank
        if ds.Rank[rootX]<ds.Rank[rootY]{
            rootX,rootY=rootY,rootX
        }
        ds.Father[rootY]=rootX
        if ds.Rank[rootX]==ds.Rank[rootY]{
            ds.Rank[rootX]++
        }
    }
}

Leetcode: 交换字符串中元素