并查集定义 / 实现 / 优化

最新推荐文章于 2022-05-27 20:12:38 发布

羽扬_

最新推荐文章于 2022-05-27 20:12:38 发布

阅读量125

点赞数

分类专栏：数据结构与算法

用自己的话讲有助于理解. 希望对你有用. 共勉.

本文链接：https://blog.csdn.net/azitl/article/details/101039276

版权

数据结构与算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

算法与数据结构之并查集
主要介绍并查集算法实现以及相关优化。

paste image
并查集 Union Find
图相关算法的实现。

一种不一样的树形结构

连接问题 Connectivity Problem
可视化的来看连接问题：

连接问题
左上右下是否是连接的呢？

意义：实际应用中的作用
网络中节点间的连接状态

网络是个抽象的概念：用户之间形成的网络
社交网络：Facebook中用户a和b中的联系（好友关系）。是否能联系到。

音乐电影书籍，多媒体之间形成网络。

互联网网页之间形成的网络

路由器和路由器之间形成的也是网络

道理交通，航班调度都是网络

数学中的集合类实现

并就是实现并集。& 查询

连接问题 & 路径问题

比路径问题要回答的问题少（路径是什么，连接问题只问有没有连）

和二分查找作比较：顺序查找法顺便回答了rank。和前面其他元素的位置
和select作比较：排好序回答问题更多。快排思路select回答问题更少
和堆作比较：只关心最大最小。
除了回答问题本身之外是不是额外的回答了别的问题。很有可能就存在
更高效的算法。：因为高效算法不需要回答额外的问题。

实现一个最简单的并查集 Union Find
对于一组数据，主要支持两个动作：

union( p , q )
find( p )
用来回答一个问题

isConnected( p , q )
最简单的表示方式；
数组。0,1.

0-4 5-9

0-4是一组，5-9是一组。组内之间有联系,一组内的元素有相同的id

奇偶

奇数是一组，偶数是一组。


namespace UF1 {

    class UnionFind {

    private:
        int *id;
        int count;

    public:
        UnionFind(int n) {
            count = n;
            id = new int[n];
            //初始条件每个元素都是一组
            for (int i = 0; i < n; i++)
                id[i] = i;
        }

        ~UnionFind() {
            delete[] id;
        }
		//传入元素p，返回元素对应的id。
        int find(int p) {
            assert(p >= 0 && p < count);
            return id[p];
        }

        bool isConnected(int p, int q) {
            return find(p) == find(q);
        }

        //传入两个元素，并
        void unionElements(int p, int q) {

            //找到两个元素的id
            int pID = find(p);
            int qID = find(q);

            //比较id
            if (pID == qID)
                return;

            for (int i = 0; i < count; i++)
                //从头到尾的扫描时间复杂度O(n)
                if (id[i] == pID)
                    id[i] = qID;
        }
    };
}
复制代码
Testhelper.h:

namespace UnionFindTestHelper{

    //n是数据量
    void testUF1( int n ){

		//
        srand( time(NULL) );
        UF1::UnionFind uf = UF1::UnionFind(n);

        time_t startTime = clock();
		
        //O(N*N)的时间复杂度
        for( int i = 0 ; i < n ; i ++ ){
            int a = rand()%n;
            int b = rand()%n;
            uf.unionElements(a,b);
            //O(n）
        }
        for(int i = 0 ; i < n ; i ++ ){
            int a = rand()%n;
            int b = rand()%n;
            uf.isConnected(a,b);
            //时间复杂度只有O(1)
        }
        time_t endTime = clock();

        cout<<"UF1, "<<2*n<<" ops, "<<double(endTime-startTime)/CLOCKS_PER_SEC<<" s"<<endl;
    }
}
复制代码
main.cpp:

int main() {

    int n = 100000;

    UnionFindTestHelper::testUF1(n);

    return 0;
}

复制代码
运行结果：

UF1, 200000 ops, 32.3533 s
[Finished in 39.7s]
复制代码
quick find 查找时只需要O(1)级别。但是并确很慢

并查集的另一种实现思路
常规实现思路

将每一个元素，看做是一个节点。

元素节点

每个元素拥有一个指向父节点的指针。然后最上面的父节点指针指向自己。

Quick Union

数组存放父亲

parent(i) = i;

初始状态
union 3 4

union 3 8

union 6 5

union 9 4

要将9连接到4的根节点8上去。数组中：4-3-8-8 8是4的根节点。9指向8.
4和9连接在一起：因为根相同。

成果

其中6和2连接是6的根0和2的根1选取了1将0挂上。
代码实现


namespace UF2{

    class UnionFind{

    private:
        int* parent;
        int count;

    public:
        UnionFind(int count){
            parent = new int[count];
            this->count = count;
            for( int i = 0 ; i < count ; i ++ )
                parent[i] = i;
        }

        ~UnionFind(){
            delete[] parent;
        }

        //不断向上找父亲
        int find(int p){
            assert( p >= 0 && p < count );
            while( p != parent[p] )
                p = parent[p];
            return p;
        }

        //看是否能找到同样的根
        bool isConnected( int p , int q ){
            return find(p) == find(q);
        }

        //找到p的根，和q的根
        void unionElements(int p, int q){

            int pRoot = find(p);
            int qRoot = find(q);

            if( pRoot == qRoot )
                return;
        //把根挂到另一个的根
            parent[pRoot] = qRoot;
        }
    };
}
复制代码
运行结果：

UF1, 20000 ops, 0.246341 s
UF2, 20000 ops, 0.059387 s
复制代码
当n大的时候，方法1更优了。

并查集的优化
问题1：
union 9,4 & union 4 9


union 9 4

9的元素少，将它指向4的根节点。形成的树层数低。

// 我们的第三版Union-Find
namespace UF3{

    class UnionFind{

    private:
        int* parent; // parent[i]表示第i个元素所指向的父节点
        int* sz;     // sz[i]表示以i为根的集合中元素个数
        int count;   // 数据个数

    public:
        // 构造函数
        UnionFind(int count){
            parent = new int[count];
            sz = new int[count];
            this->count = count;
            for( int i = 0 ; i < count ; i ++ ){
                parent[i] = i;
                sz[i] = 1;
            }
        }

        // 析构函数
        ~UnionFind(){
            delete[] parent;
            delete[] sz;
        }

        // 查找过程, 查找元素p所对应的集合编号
        // O(h)复杂度, h为树的高度
        int find(int p){
            assert( p >= 0 && p < count );
            // 不断去查询自己的父亲节点, 直到到达根节点
            // 根节点的特点: parent[p] == p
            while( p != parent[p] )
                p = parent[p];
            return p;
        }

        // 查看元素p和元素q是否所属一个集合
        // O(h)复杂度, h为树的高度
        bool isConnected( int p , int q ){
            return find(p) == find(q);
        }

        // 合并元素p和元素q所属的集合
        // O(h)复杂度, h为树的高度
        void unionElements(int p, int q){

            int pRoot = find(p);
            int qRoot = find(q);

            if( pRoot == qRoot )
                return;

            // 根据两个元素所在树的元素个数不同判断合并方向
            // 将元素个数少的集合合并到元素个数多的集合上
            if( sz[pRoot] < sz[qRoot] ){
                parent[pRoot] = qRoot;
                sz[qRoot] += sz[pRoot];
            }
            else{
                parent[qRoot] = pRoot;
                sz[pRoot] += sz[qRoot];
            }
        }
    };
}

复制代码
运行结果：

UF2, 200000 ops, 19.3316 s
UF3, 200000 ops, 0.0184 s
复制代码
分析
对于UF1来说，虽然isConnected只需要O(1)的时间, 但由于union操作需要O(n)的时间；总体测试过程的算法复杂度是O(n^2)的
对于UF2来说, 其时间性能是O(nh)的, h为并查集表达的树的最大高度
这里严格来讲, h和logn没有关系, 不过大家可以简单这么理解
我们后续内容会对h进行优化, 总体而言, 这个h是远小于n的
所以我们实现的UF2测试结果远远好于UF1, n越大越明显:)
对于UF3来说, 其时间性能依然是O(nh)的, h为并查集表达的树的最大高度
但由于UF3能更高概率的保证树的平衡, 所以性能更优
基于rank的并查集优化
分析

上面合并4和2 依靠集合的size来决定谁指向谁并不完全合理。根据层数才最合理。

基于rank的优化
用rank[i] 表示根节点为i的树的高度

namespace UF4{

    class UnionFind{

    private:
        int* rank;   // rank[i]表示以i为根的集合所表示的树的层数
        int* parent; // parent[i]表示第i个元素所指向的父节点
        int count;   // 数据个数

    public:
        // 构造函数
        UnionFind(int count){
            parent = new int[count];
            rank = new int[count];
            this->count = count;
            for( int i = 0 ; i < count ; i ++ ){
                parent[i] = i;
                rank[i] = 1;
            }
        }

        // 析构函数
        ~UnionFind(){
            delete[] parent;
            delete[] rank;
        }

        // 查找过程, 查找元素p所对应的集合编号
        // O(h)复杂度, h为树的高度
        int find(int p){
            assert( p >= 0 && p < count );
            // 不断去查询自己的父亲节点, 直到到达根节点
            // 根节点的特点: parent[p] == p
            while( p != parent[p] )
                p = parent[p];
            return p;
        }

        // 查看元素p和元素q是否所属一个集合
        // O(h)复杂度, h为树的高度
        bool isConnected( int p , int q ){
            return find(p) == find(q);
        }

        // 合并元素p和元素q所属的集合
        // O(h)复杂度, h为树的高度
        void unionElements(int p, int q){

            int pRoot = find(p);
            int qRoot = find(q);

            if( pRoot == qRoot )
                return;

            // 根据两个元素所在树的元素个数不同判断合并方向
            // 将元素个数少的集合合并到元素个数多的集合上
            if( rank[pRoot] < rank[qRoot] ){
                parent[pRoot] = qRoot;
            }
            else if( rank[qRoot] < rank[pRoot]){
                parent[qRoot] = pRoot;
            }
            else{ // rank[pRoot] == rank[qRoot]
                parent[pRoot] = qRoot;
                rank[qRoot] += 1;   // 此时, 我维护rank的值
            }
        }
    };
}

复制代码
分析
对于UF3来说, 其时间性能依然是O(n*h)的, h为并查集表达的树的最大高度，但由于UF3能更高概率的保证树的平衡, 所以性能更优

UF4虽然相对UF3进行有了优化, 但优化的地方出现的情况较少,所以性能更优表现的不明显, 甚至在一些数据下性能会更差,因为判断更多了。

运行结果

2000000 ops, 0.313945 s
复制代码
路径压缩（path Compression）
前面我们都在优化union。其实Find我们也可以进行优化。由于每个节点存的都是它的父亲节点，所有每个节点都可以有无数个（多个）孩子。在search值的时候，对于没有找到的根的节点，可以往上挪一挪。

分析

比如我们要find4

我们将4的父亲节点连接为4的父亲的父亲（如果出现3就是根节点，也没有关系，因为对于根节点来说，3的父亲还是3）

下面考虑4的parent:2 (此时跳过了3，跳2级是没有问题的）

最后的结果：

修改 find函数

int find(int p){
assert( p >= 0 && p < count );

  // path compression 1
  while( p != parent[p] ){
    parent[p] = parent[parent[p]];
    p = parent[p];
  }
}

复制代码
最优结果的代码实现

  //path compression 2, 递归算法
  if( p != parent[p] )
  parent[p] = find( parent[p] );
  return parent[p];

复制代码
最后的情况

写一个递归的函数：调用findx，返回的就是x节点的根。让每个parentx指向findx的结果。findx的结果也是Findparentx的结果。找x的时候，将x的Findparent的结果，指向父亲的结果。
优化情况并不明显。甚至因为递归的消耗。所以理论最优不一定实际好。

经过并查集的优化，并查集的操作，时间复杂度近乎是O(1)的

并查集 定义 / 实现 / 优化

并查集定义 / 实现 / 优化