【數據結構】之並查集簡易封裝

原理可以看上一節:【數據結構】之實現並查集

下面對並查集進行簡單的封裝:

頭文件union_find.h:

#ifndef INC_6_FOOD_LINK_UNION_H
#define INC_6_FOOD_LINK_UNION_H

#include <malloc.h>
#include <memory.h>

typedef struct UnionFind{
    unsigned int size;
    int *par;
    int *rank;
    int (*findRoot)(struct UnionFind*, int);
    void (*unite)(struct UnionFind*, int, int);
    int (*same)(struct UnionFind*, int, int);
    void (*delete)(struct UnionFind*);
} UnionFind;

//構造函數
UnionFind* new_UnionFind(unsigned int);
//查找樹的根
int findRoot(UnionFind*, int);
//合併
void unite(UnionFind*, int, int);
//判斷兩個元素是否屬於同一集合
int same(UnionFind*, int, int);
//釋放
void delete(UnionFind*);

#endif //INC_6_FOOD_LINK_UNION_H

實現union_find.c:

#include "union_find.h"

extern UnionFind* new_UnionFind(unsigned int size){
    UnionFind *unionFind = malloc(sizeof(UnionFind));
    unionFind->size = size;
    unionFind->par = malloc(sizeof(int) * size);
    unionFind->rank = malloc(sizeof(int) * size);
    for (int i = 0; i < size; ++i) {
        unionFind->par[i] = i;
    }
    memset(unionFind->rank, 0, sizeof(int) * size);
    unionFind->findRoot = &findRoot;
    unionFind->unite = &unite;
    unionFind->same = &same;
    unionFind->delete = &delete;
    return unionFind;
}

extern int findRoot(UnionFind* uf, int x){
    int *par = uf->par;
    if (x == par[x])
        return x;
    return par[x] = findRoot(uf, par[x]);
}

extern void unite(UnionFind* uf, int x, int y){
    x = findRoot(uf, x);
    y = findRoot(uf, y);
    if (x == y)
        return;
    if (uf->rank[x] < uf->rank[y]){
        uf->par[x] = uf->par[y];
    } else {
        uf->par[y] = uf->par[x];
        if (uf->rank[x] == uf->rank[y])
            uf->rank[x]++;
    }
}

int same(UnionFind* uf, int x, int y){
    return findRoot(uf, x) == findRoot(uf, y);
}

void delete(UnionFind* uf){
    free(uf->par);
    free(uf->rank);
    free(uf);
}

下一篇打算用這個封裝解決一個食物鏈問題:【數據結構】之利用並查集解決食物鏈問題