算法与数据结构-并查集（并查集森林）（优化）（C++）

描述

并查集是一种用于处理一些不相交集合的合并和查询问题的树型数据结构。通常在使用中以森林来表示。用森林的好处是降低了在合并（Union）操作时的时间复杂度。本文以并查集森林实现为例，学习该数据结构。

思路

• 用顺序表的形式来存储每个结点，每个结点的内容为该结点的直接父结点。例如，parent[i]表示第i个节点的父结点的索引。
• 为了使并（Union）操作时尽可能保持较低的树高度，新增一个size顺序表，size[i]表示以i为根结点所在的树中结点的个数。
• 初始化令每个结点的父结点为自身，相应的size都为1。
• 查找操作。对传入的索引进行查找，返回所在树的根节点的索引。就是一个向上遍历的过程，直到索引的父结点等于自身就为根节点。
• 合并操作。把树高度较低的那棵树的根节点指向另一棵树的根节点。parent[pRoot] = qRoot，两棵树合并为了一棵树。

实现代码

//UF1.h
#include<iostream>
#include<cassert>
using namespace std;

namespace UF1 {
    class UnionFind {
    private:
        int *parent;    //表示第i个元素的父结点
        int *size;      //表示以i为根的集合中的结点个数
        int count;      //结点总数

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

        ~UnionFind() {
            delete[] parent;
            delete[] size;
        }

        int find(int p) {
            while(p != parent[p]) {
                p = parent[p];
            }
            return p;
        }

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

        void unionElement(int p, int q) {
            int pRoot = find(p);
            int qRoot = find(q);

            if(pRoot == qRoot)
                return;
            if(size[pRoot] < size[qRoot]) {
                parent[pRoot] = qRoot;
                size[qRoot] += size[pRoot];
            }
            else {
                parent[qRoot] = pRoot;
                size[pRoot] += size[qRoot];
            }
            return;
        }
    };
}

优化

为了降低树的高度，这里采用了计算每棵树的结点个数从而判断要接到哪棵树的根上。但是，并不一定结点数多树的高度就一定高，所以我们可以引入一个rank顺序表，rank[i]表示以i为根节点的树的层数。
具体实现如下：

//UF2.h
#include<iostream>
#include<ctime>
using namespace std;

namespace UF2 {
    class UnionFind {
    private:
        int *parent;
        int *rank;      //rank[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;
        }

        int find(int p) {
            while(p != parent[p]) {
                p = parent[p];
            }
            return p;
        }

        bool isConnected(int p, int q) {
            return parent[p] == parent[q];
        }

        void unionElement(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 {
                parent[pRoot] = qRoot;
                rank[qRoot] += 1;
            }
        }
    };
}

测试

测试代码如下：

#include<iostream>
#include<ctime>
#include"UF1.h"
#include"UF2.h"
using namespace std;

namespace test {
    void testUF1(int n) {
        UF1::UnionFind uf1(n);
        srand(time(NULL));
        clock_t beginTime = clock();    //开始计时
        //并操作
        for(int i = 0; i < n; i++) {
            uf1.unionElement(rand()%n, rand()%n);
        }

        for(int i = 0; i < n; i++) {
            uf1.isConnected(rand()%n, rand()%n);
        }
        clock_t endTime = clock();      //结束

        cout << "UF1 cost time is :" << double(endTime - beginTime) / CLOCKS_PER_SEC << " s" << endl;
    }

    void testUF2(int n) {
        UF2::UnionFind uf2(n);
        srand(time(NULL));

        clock_t beginTime = clock();
        //并操作
        for(int i = 0; i < n; i++) {
            uf2.unionElement(rand()%n, rand()%n);
        }

        for(int i = 0; i < n; i++) {
            uf2.isConnected(rand()%n, rand()%n);
        }
        clock_t endTime = clock();      //结束

        cout << "UF1 cost time is :" << double(endTime - beginTime) / CLOCKS_PER_SEC << " s" << endl;

    }
}

int main(int argc, char const *argv[])
{
    int n = 10000000;
    test::testUF1(n);
    test::testUF2(n);
    
    return 0;
}

测试结果：

UF1 cost time is :1.459 s
UF1 cost time is :1.118 s

最后

• 由于博主水平有限，难免有疏漏之处，欢迎读者批评指正！