数据结构之并查集

最新推荐文章于 2023-04-08 20:18:35 发布
最新推荐文章于 2023-04-08 20:18:35 发布
阅读量356 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39084521/article/details/90322597
版权
数据结构并查集的学习：

并查集

在计算机科学中， 并查集是一种树型的数据结构 ，用于处理一些不交集（Disjoint Sets）的合并及查询问题。 有一个联合-查找算法 （ union-find algorithm ）定义了两个用于此数据结构的操作：

  • Find：确定元素属于哪一个子集。 它可以被用来确定两个元素是否属于同一子集。
  • Union：将两个子集合并成同一个集合。

由于支持这两种操作，一个不相交集也常被称为联合-查找数据结构（union-find data structure）或合并-查找集合（merge-find set）。 其他的重要方法，MakeSet，用于建立单元素集合。 有了这些方法，许多经典的划分问题可以被解决。

为了更加精确的定义这些方法，需要定义如何表示集合。 一种常用的策略是为每个集合选定一个固定的元素，称为代表，以表示整个集合。 接着，Find(x) 返回x 所属集合的代表，而Union 使用两个集合的代表作为参数。

UF

1
2
3
4
5
public interface UF {
    int getSize();
    boolean isConnected(int p,int q);
    void UnionElements(int p,int q);
}

QuickFind

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
//第一版Union-Find 查询为O(1)级别十分块 缺点:Union的时间复杂度为O(n)
public class UnionFind1 implements UF {
    private int[] id;

    public UnionFind1(int size) {
        id = new int[size];

        for (int i = 0; i < id.length; i++) {
            id[i] = i;
        }
    }

    @Override
    public int getSize() {
        return id.length;
    }

    //查找元素p所对应的集合编号
    private int find(int p) {
        if (p < 0 && p >= id.length) {
            throw new IllegalArgumentException("p  is out of bound.");
        }
        return id[p];
    }

    //查看元素p和元素q是否属于一个集合
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }

    //合并元素p和元素q是否属于一个集合
    @Override
    public void UnionElements(int p, int q) {
        int pID = find(p);
        int qID = find(q);

        if (pID == qID) {
            return;
        }
        for (int i = 0; i < id.length; i++) {
            if (id[i] == pID) {
                id[i] = qID;
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
//第二版Union-Find
public class UniomFind2 implements UF {
    private int[] parent;

    public UniomFind2(int size) {

        parent = new int[size];

        for (int i = 0; i < size; i++) {
            parent[i] = i;
        }
    }

    @Override
    public int getSize() {
        return parent.length;
    }

    //查找过程,查找元素p所对应的集合编号
    //O(h)复杂度,h为树的高度
    private int find(int p) {

        if ((p < 0 && p >= parent.length)) {
            throw new IllegalArgumentException("p is out of bound.");
        }
        while (p != parent[p]) {
            p = parent[p];
        }
        return p;
    }

    //产看元素是否属于一个集合
    //O(h)复杂度,h为树的高度
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }


    //合并元素p和元素q所属的元素
    //O(h)复杂度,h为树的高度
    @Override
    public void UnionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (qRoot == pRoot) {
            return;
        }
        parent[pRoot] = qRoot;
    }
}

QuickUnion

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
//第二版Union-Find 将每一个元素看作一个节点,节点之间相连接我们看成一个树结构,,孩子指向父亲.通常的实现思路
public class UniomFind2 implements UF {
    private int[] parent;

    public UniomFind2(int size) {

        parent = new int[size];

        for (int i = 0; i < size; i++) {
            parent[i] = i;
        }
    }

    @Override
    public int getSize() {
        return parent.length;
    }

    //查找过程,查找元素p所对应的集合编号
    //O(h)复杂度,h为树的高度
    private int find(int p) {

        if ((p < 0 && p >= parent.length)) {
            throw new IllegalArgumentException("p is out of bound.");
        }
        while (p != parent[p]) {
            p = parent[p];
        }
        return p;
    }

    //产看元素是否属于一个集合
    //O(h)复杂度,h为树的高度
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }


    //合并元素p和元素q所属的元素
    //O(h)复杂度,h为树的高度
    @Override
    public void UnionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (qRoot == pRoot) {
            return;
        }
        parent[pRoot] = qRoot;
    }
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.util.Random;

public class Main {
    private static double testUF(UF uf, int m) {
        int size = uf.getSize();
        Random random = new Random();

        long startTime = System.nanoTime();
        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.UnionElements(a, b);
        }
        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.isConnected(a, b);
        }

        long endTime = System.nanoTime();
        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        int size = 100000;
        int m = 100000;
        UnionFind1 uf1 = new UnionFind1(size);
        System.out.println("UnionFind1: " + testUF(uf1, m) + "s");

        UniomFind2 uf2 = new UniomFind2(size);
        System.out.println("UnionFind2: " + testUF(uf2, m) + "s");
    }
}

分析:

UnionFind1整体使用的是一个数组,合并操作,是对连续的内存进行一次循环操作,JVM,对此有很好的优化,对于UnionFind2来说,查询的过程是一个不断索引的过程,不是顺次访问一片连续的内存空间,要在不同的地址之间进行跳转.因此速度会慢一些.在UnionFInd2中Find的时间复杂度为O(h)级别的,操作数越大Union中更多的元素被组织到了一个集合中去.这样树会非常大,

但是又有退化成链表的风险.

Size优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
//第三版Union-Find    Size优化 降低树高
public class UniomFind3 implements UF {
    private int[] parent;
    private int[] sz; //sz[i]表示以i为根的集合中元素个数


    public UniomFind3(int size) {

        parent = new int[size];
        sz = new int[size];

        for (int i = 0; i < size; i++) {
            parent[i] = i;
            sz[i] = 1;
        }
    }

    @Override
    public int getSize() {
        return parent.length;
    }

    //查找过程,查找元素p所对应的集合编号
    //O(h)复杂度,h为树的高度
    private int find(int p) {

        if ((p < 0 && p >= parent.length)) {
            throw new IllegalArgumentException("p is out of bound.");
        }
        while (p != parent[p]) {
            p = parent[p];
        }
        return p;
    }

    //产看元素是否属于一个集合
    //O(h)复杂度,h为树的高度
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }


    //合并元素p和元素q所属的元素
    //O(h)复杂度,h为树的高度
    @Override
    public void UnionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (qRoot == pRoot) {
            return;
        }
        //根据两个元素所在树的元素个数不同判断合并方向
        //将元素个数少的集合合并到元素个数多的集合
        if (sz[pRoot] < sz[qRoot]) {
            parent[pRoot] = qRoot;
            sz[pRoot] += sz[qRoot];
        } else {
            parent[qRoot] = pRoot;
            sz[pRoot] += sz[qRoot];
        }
    }
}
测试
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.util.Random;

public class Main {
    private static double testUF(UF uf, int m) {
        int size = uf.getSize();
        Random random = new Random();

        long startTime = System.nanoTime();
        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.UnionElements(a, b);
        }
        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.isConnected(a, b);
        }

        long endTime = System.nanoTime();
        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        int size = 100000;
        int m = 100000;
        UnionFind1 uf1 = new UnionFind1(size);
        System.out.println("UnionFind1: " + testUF(uf1, m) + "s");

        UniomFind2 uf2 = new UniomFind2(size);
        System.out.println("UnionFind2: " + testUF(uf2, m) + "s");
        UniomFind3 uf3 = new UniomFind3(size);
  		System.out.println("UnionFind3: " + testUF(uf3, m) + "s");

    }
}

分析:

在UnionFInd3中,我们可以确保树的深度是十分浅的,虽然时间复杂度为O(h)但是h很小因此,效率会很高.对于UnionFind2来说,在极端情况下,会退化成一个链表.

Rank优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
//第四版Union-Find  基于Rank优化
public class UniomFind4 implements UF {
    private int[] parent;
    private int[] rank; //rank[i]表示以i为根的集合所表示的树的层数

    public UniomFind4(int size) {

        parent = new int[size];
        rank = new int[size];

        for (int i = 0; i < size; i++) {
            parent[i] = i;
            rank[i] = 1;
        }
    }

    @Override
    public int getSize() {
        return parent.length;
    }

    //查找过程,查找元素p所对应的集合编号
    //O(h)复杂度,h为树的高度
    private int find(int p) {

        if ((p < 0 && p >= parent.length)) {
            throw new IllegalArgumentException("p is out of bound.");
        }
        while (p != parent[p]) {
            p = parent[p];
        }
        return p;
    }

    //产看元素是否属于一个集合
    //O(h)复杂度,h为树的高度
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }


    //合并元素p和元素q所属的元素
    //O(h)复杂度,h为树的高度
    @Override
    public void UnionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (qRoot == pRoot) {
            return;
        }
        //根据两个元素所在树的rank不同判断合并方向
        //rank低的集合合并到rank高的集合上
        if (rank[pRoot] < rank[qRoot]) {
            parent[pRoot] = qRoot;
            //qRoot的树高没有发生变化
        } else if (rank[qRoot] < rank[pRoot]) {
            parent[qRoot] = pRoot;
        } else {  //rank[qRoot] == rank[pRoot]
            parent[qRoot] = pRoot;
            rank[pRoot] += 1;
        }
    }
}
测试
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.util.Random;

public class Main {
    private static double testUF(UF uf, int m) {
        int size = uf.getSize();
        Random random = new Random();

        long startTime = System.nanoTime();
        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.UnionElements(a, b);
        }
        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.isConnected(a, b);
        }

        long endTime = System.nanoTime();
        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        int size = 10000000;
        int m = 10000000;
        UniomFind3 uf3 = new UniomFind3(size);

        System.out.println("UnionFind3: " + testUF(uf3, m) + "s");
        UniomFind4 uf4 = new UniomFind4(size);
        System.out.println("UnionFind4: " + testUF(uf4, m) + "s");
    }
}

对于千万级别的数据的,由于实现并查集的时候,基于Rank的要比基于Size逻辑上更加合理,因此我们大多情况下实现一个并查集是基于Rank实现的.

路径压缩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
//第五版Union-Find 路径压缩
public class UniomFind5 implements UF {
    private int[] parent;
    private int[] rank; //rank[i]表示以i为根的集合所表示的树的层数

    public UniomFind5(int size) {

        parent = new int[size];
        rank = new int[size];

        for (int i = 0; i < size; i++) {
            parent[i] = i;
            rank[i] = 1;
        }
    }

    @Override
    public int getSize() {
        return parent.length;
    }

    //查找过程,查找元素p所对应的集合编号
    //O(h)复杂度,h为树的高度
    private int find(int p) {

        if ((p < 0 && p >= parent.length)) {
            throw new IllegalArgumentException("p is out of bound.");
        }
        while (p != parent[p]) {
            parent[p] =     parent[parent[p]];
            p = parent[p];
        }
        return p;
    }

    //产看元素是否属于一个集合
    //O(h)复杂度,h为树的高度
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }


    //合并元素p和元素q所属的元素
    //O(h)复杂度,h为树的高度
    @Override
    public void UnionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (qRoot == pRoot) {
            return;
        }
        //根据两个元素所在树的rank不同判断合并方向
        //rank低的集合合并到rank高的集合上
        if (rank[pRoot] < rank[qRoot]) {
            parent[pRoot] = qRoot;
            //qRoot的树高没有发生变化
        } else if (rank[qRoot] < rank[pRoot]) {
            parent[qRoot] = pRoot;
        } else {  //rank[qRoot] == rank[pRoot]
            parent[qRoot] = pRoot;
            rank[pRoot] += 1;
        }
    }
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.util.Random;

public class Main {
    private static double testUF(UF uf, int m) {
        int size = uf.getSize();
        Random random = new Random();

        long startTime = System.nanoTime();
        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.UnionElements(a, b);
        }
        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.isConnected(a, b);
        }

        long endTime = System.nanoTime();
        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        int size = 10000000;
        int m = 10000000;
        
        UniomFind3 uf3 = new UniomFind3(size);

        System.out.println("UnionFind3: " + testUF(uf3, m) + "s");
        UniomFind4 uf4 = new UniomFind4(size);
        System.out.println("UnionFind4: " + testUF(uf4, m) + "s");
        UniomFind5 uf5 = new UniomFind5(size);
        System.out.println("UnionFind5: " + testUF(uf5, m) + "s");
    }
}

路径压缩[递归]

实际上当我们使用路径压缩的时候,希望路径直接压缩成这个样子的.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
//第六版Union-Find 路径压缩递归实现
public class UniomFind6 implements UF {
    private int[] parent;
    private int[] rank; //rank[i]表示以i为根的集合所表示的树的层数

    public UniomFind6(int size) {

        parent = new int[size];
        rank = new int[size];

        for (int i = 0; i < size; i++) {
            parent[i] = i;
            rank[i] = 1;
        }
    }

    @Override
    public int getSize() {
        return parent.length;
    }

    //查找过程,查找元素p所对应的集合编号
    //O(h)复杂度,h为树的高度
    private int find(int p) {

        if ((p < 0 && p >= parent.length)) {
            throw new IllegalArgumentException("p is out of bound.");
        }
        while (p != parent[p]) {
            parent[p] = find(parent[p]);
            p = parent[p];
        }
        return p;
    }

    //产看元素是否属于一个集合
    //O(h)复杂度,h为树的高度
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }


    //合并元素p和元素q所属的元素
    //O(h)复杂度,h为树的高度
    @Override
    public void UnionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (qRoot == pRoot) {
            return;
        }
        //根据两个元素所在树的rank不同判断合并方向
        //rank低的集合合并到rank高的集合上
        if (rank[pRoot] < rank[qRoot]) {
            parent[pRoot] = qRoot;
            //qRoot的树高没有发生变化
        } else if (rank[qRoot] < rank[pRoot]) {
            parent[qRoot] = pRoot;
        } else {  //rank[qRoot] == rank[pRoot]
            parent[qRoot] = pRoot;
            rank[pRoot] += 1;
        }
    }
}
测试
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import java.util.Random;

public class Main {
    private static double testUF(UF uf, int m) {
        int size = uf.getSize();
        Random random = new Random();

        long startTime = System.nanoTime();
        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.UnionElements(a, b);
        }
        for (int i = 0; i < m; i++) {
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.isConnected(a, b);
        }

        long endTime = System.nanoTime();
        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        int size = 10000000;
        int m = 10000000;

        UniomFind3 uf3 = new UniomFind3(size);

        System.out.println("UnionFind3: " + testUF(uf3, m) + "s");
        UniomFind4 uf4 = new UniomFind4(size);
        System.out.println("UnionFind4: " + testUF(uf4, m) + "s");
        UniomFind5 uf5 = new UniomFind5(size);
        System.out.println("UnionFind5: " + testUF(uf5, m) + "s");
        UniomFind6 uf6 = new UniomFind6(size);
        System.out.println("UnionFind6: "  + testUF(uf6, m) + "s");

    }
}

虽然UnionFind6理论上最大压缩了树,但是由于时基于递归实现 虽然会有一丁点的时间消耗但是这次我们测试的数据总量数据千万级别的,因此使用递归实现的压缩,要比非递归实现的要差那么一点点.

并查集时间复杂度

参考资料

《玩转数据结构》

清风笑丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构——并查集
weixin_38384296的博客
05-16 1684
并查集是一种数据结构，是树的一种应用，用于处理一些不交集（一系列没有重复元素的集合）的合并以及查询问题。并查集支持如下操作： 查询：查询某个元素属于哪个集合，通常是返回集合内的一个“代表元素”。这个操作一般是为了判断两个元素是否在同一个集合之中。 合并：将两个集合合并为一个。 添加：添加一个新集合，其中有一个新元素。不如查询和合并操作重要。 我们来看下面一个比较有趣的并查集应用的例子： 话说江湖上散落着各式各样的大侠，有上千个之多。他们没有什么正当职业，整天背着剑在外面走来走去，碰到和自己不是一路人的
数据结构 之 并查集
小邓笔记
11-24 4382
并查集是一种树型的数据结构，其保持着用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。 有一个联合-查找算法（union-find algorithm）定义了两个操作用于此数据结构： Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。Union：将两个子集合并成同一个集合。 下面代码实现一些并查集中的一些基本操作： 一、并查集的
【数据结构】--并查集
最新发布
m0_63077733的博客
04-08 1390
初始化时，每个元素各自属于一个单元素集合i++) {不是固定的让某一棵树嫁接到另一棵树，让元素少的树 嫁接到 元素多的树。/*** Quick Union--基于size的优化*/// 该数组存放以size[i]为根节点的节点个数i++){// 初始化一个根节点只有一个节点【就是它本身】sizes[i]=1;/*** 将v1所在的根节点 嫁接到v2的根节点上*/@Overridereturn;//如果v1所在的树的长度<v2所在的树的长度，则将v1嫁接到v2上。
数据结构 -- 并查集
热门推荐
Enstein_Jun
08-10 2万+
1、什么是并查集        并查集是一种用于管理分组的数据结构。它具备两个操作：(1)查询元素a和元素b是否为同一组   (2) 将元素a和b合并为同一组。 注意：并查集不能将在同一组的元素拆分为两组。 2、并查集的结构       并查集可以使用树来实现。
c语言数据结构之并查集 总结
12-31
并查集(Union-Find Set)： 一种用于管理分组的数据结构。它具备两个操作：(1)查询元素a和元素b是否为同一组 (2) 将元素a和b合并为同一组。 注意：并查集不能将在同一组的元素拆分为两组。 并查集的实现： 用树来实现...
数据结构之并查集（模板）
08-17
并查集实现，带路径压缩和template，高效查找神器！注：库里面如果没有unordered_map，可以换成hash_map或者map
数据结构之并查集：按秩合并与路径压缩优化
Sakura_lht
11-15 2137
并查集 1.并查集描述 一些有NNN个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。 为了快速解决这些问题，便有了并查集的概念。 并查集维护了一个不相交的动态集的集合S1,S2,⋯ ,Sn{S_1,S_2,\cdots,S_n}S1​,S2​,⋯,Sn​，每个集合将有一个"首领"来标识该集...
ACM-数据结构-并查集学习
02-20
ACM-数据结构-并查集学习
并查集
eriol的思考空间
09-25 152
1. 概述 并查集（Disjoint set或者Union-find set）是一种树型的数据结构，常用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。 2. 基本操作 并查集是一种非常简单的数据结构，它主要涉及两个基本操作，分别为： 合并两个不相交集合。 判断两个元素是否属于同一个集合。   (1) 合并两个不相交集合（Union(x,y)） ...
【数据结构】并查集
aaronlanni的博客
04-11 328
一、基本概念 并查集是一种树型的数据结构，用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。常常在使用中以森林来表示。集就是让每个元素构成一个单元素的集合，也就是按一定顺序将属于同一组的元素所在的集合合并。在一些有N个元素的集合应用问题中，通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。 1、概
数据结构---并查集
weixin_30536513的博客
08-10 100
并查集，顾名思义，合并 查找 集合； 并查集是一种树型的数据结构，用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。常常在使用中以森林来表示。 对于概念等等的这里不再赘述，直接讲解应用。 应用1：判断图中有多少联通分量 ， 或者图是否联通（联通分量 == 1） HDU 1213 应用2：判断图是否成环 给个例题 HDU2120 ...
数据结构 - 并查集
yiguang_820的博客
08-02 408
目录： 基本概念 存储方式 单链表表示 并查集森林 并查集森林的两种改进策略 按秩合并（union by rank） 路径压缩（path compression) 应用 一.基本概念 不相交集类维持着多个彼此之间没有交集的子集的集合，可以用于 判断两个元素是否属于同一个集合，或者合并两个不相交的子集。比如， { {1,3,5}，{2}，{4}，{6,7} } 这整体就是一个不相交集合。里面的一些子集也是彼此互不相交的。 注意，对于每一个子集，往往用某一个元素来代表，..
C语言实现并查集数据结构详解
"c语言数据结构之并查集总结，并查集是一种用于管理分组的数据结构，支持查询元素是否在同一组以及合并元素到同一组的操作。实现方式通常使用树形结构，通过查找元素的根节点来判断它们是否属于同一组。在C语言中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值