数据结构与算法C++之并查集

并查集 Union Find
可以解决连接问题和路径问题

下图中使用id表示数组，第一行表示其索引，第二行表示元素值，为0的元素表示是互相连接在一起的，同样为1的元素表示互相连接在一起的


下面是测试一个并查集 Union 操作的计算复杂度

#include <iostream>
#include <cassert>
#include "UnionFindTestHelper.h"

using namespace std;

int main()
{
    int n = 100000;
    UnionFindTestHelper::testUF1(n);

    return 0;
}

"UnionFindTestHelper.h"为

//UnionFindTestHelper.h
#include <iostream>
#include <ctime>
#include <cstdlib> //rand()函数
#include "UnionFind1.h"

using namespace std;

namespace UnionFindTestHelper{

    void testUF1(int n){
        srand(time(NULL));
        UF1::UnionFind uf = UF1::UnionFind(n);

        time_t startTime = clock();

        for(int i = 0; i < n; i++){
            int a = rand()%n;
            int b = rand()%n;
            uf.unionElements(a, b);
        }
        for(int i = 0; i < n; i++){
            int a = rand()%n;
            int b = rand()%n;
            uf.isConnected(a, b);
        }
        time_t endTime = clock();

        cout<<"UF1, "<<2*n<<" ops, "<<double(endTime-startTime)/CLOCKS_PER_SEC<<" s"<<endl;
    }

}

"UnionFind1.h"为

#include <iostream>
#include <cassert>

using namespace std;

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;
        }

        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){
            int pID = find(p);
            int qID = find(q);

            if ( pID == qID )
                return;

            for(int i = 0; i < count; i++){
                if( id[i] == pID )
                    id[i] = qID;
            }
        }
    };
}

输出为

可以看出执行20万个操作用时9秒多，时间还是很长的
由于for循环遍历一遍n个元素，复杂度为O(n)
unionElements，复杂度为O(n),
所以最终复杂度为O(n²)，当然就慢啦