并查集原理及联通分量个数问题

最新推荐文章于 2025-02-22 19:44:58 发布

StarLib

最新推荐文章于 2025-02-22 19:44:58 发布

阅读量643

点赞数

CC 4.0 BY-SA版权

分类专栏： Algorithm

本文链接：https://blog.youkuaiyun.com/StarLib/article/details/106108198

Algorithm 专栏收录该内容

8 篇文章

订阅专栏

本文介绍了并查集这一数据结构，包括其基本原理、集合运算、存储实现、图示解析和抽象数据类型。重点讨论了针对树退化问题的优化策略，如Rank定义和路径压缩，并提供了优化后的代码实现示例，结合LC #547题解答，深入理解并查集在查找联通分量个数问题中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

title: 并查集原理及联通分量个数问题
date: 2020-05-13 20:39:28
tags:

并查集原理及联通分量个数问题

文章目录

并查集原理及联通分量个数问题
- 一、并查集

一、并查集

并查集是一个复杂的数据结构。在lc中大概有30道题左右（官方给出）

集合运算

常见的集合运算有：

交、并、补、差、判定一个元素是否属于某一集合

并查集： 集合并、查某元素属于什么集合

存储实现

使用树结构表示集合，树的每个结点代表一个集合元素

图示

如图所示有两个集合，如何判定A-I九个元素属于哪个集合？

例：E 和 C是否为同一个集合。

可以不停的向上查找元素的父节点。判断是否有同一个根节点：

E->B->A

C->A

可见 E和C是同一集合

实际刷题中往往会给一个关系矩阵, 需要自己创建所有集合。

初始化每个元素为一个集合：

有九个集合，通过关系矩阵在集合进行并操作：

例：在关系矩阵中，A和B在同一集合。则将{A}和{B}并起来。即B指向A。

最终构造出由关系矩阵得到的并查集

抽象数据

元素类型：

class Node(object):
    def __init__(self, data, parent=None):
        self.data = data
        self.parent = parent
        
class DisjointSet(object):
    def __init__(self):
        self.map = {}
        self.num_sets = 0

    def make_set(self, data):
        node = Node(data)
        node.parent = node
        self.map[data] = node
        self.num_sets += 1
    
    def union(self, data1, data2):
        pass
    
    def find(self, data):
        pass

优化

随着树的高度的增加，find方法进行查询的时候，随着大量的union操作调用，导致复杂度的线性上升。导致树结构变成一个类似于线性表的结构。这种变化叫做树的退化，并查集算法需要对此问题进行优化。

定义Rank

对于每棵树，记录树的高度Rank，当进行union操作，合并两棵树时，如果其Rank不同，那么由Rank小树的连向Rank大的树。

上图中左边的树Rank=3，右边的树Rank=2，Rank小的连向Rank大的。

路径压缩

上图中C的根节点是A，可以直接将C指向A，进行路径压缩操作。

优化后的代码实现

class Node(object):
    def __init__(self, data, parent=None, rank=0):
        self.data = data
        self.parent = parent
        self.rank = rank
class DisjointSet(object):
    def __init__(self):
        self.map = {}
        self.num_sets = 0
    def make_set(self, data):
        node = Node(data)
        node.parent = node
        self.map[data]=node
        self.num_sets+=1
    def find(self, data):
        node = self.map[data]
        r = node
        while r!= r.parent:
            r = r.parent
        k = node
        while k!=r:
            j = k.parent
            k.parent = r
            k = j
        return r
    def union(self, data1, data2):
        parent1 = self.find(data1)
        parent2 = self.find(data2)
        if parent1.data == parent2.data:
            return
        if parent1.rank >= parent2.rank:
            if parent1.rank == parent2.rank:
                parent1.rank+=1
            parent2.parent = parent1
        else:
            parent1.parent = parent2
        self.num_sets -=1

LC #547

LeetCode第547题的答案就出来了：

class Node(object):
    def __init__(self, data, parent=None, rank=0):
        self.data = data
        self.parent = parent
        self.rank = rank
class DisjointSet(object):
    def __init__(self):
        self.map = {}
        self.num_sets = 0
    def make_set(self, data):
        node = Node(data)
        node.parent = node
        self.map[data]=node
        self.num_sets+=1
    def find(self, data):
        node = self.map[data]
        r = node
        while r!= r.parent:
            r = r.parent
        k = node
        while k!=r:
            j = k.parent
            k.parent = r
            k = j
        return r
    def union(self, data1, data2):
        parent1 = self.find(data1)
        parent2 = self.find(data2)
        if parent1.data == parent2.data:
            return
        if parent1.rank >= parent2.rank:
            if parent1.rank == parent2.rank:
                parent1.rank+=1
            parent2.parent = parent1
        else:
            parent1.parent = parent2
        self.num_sets -=1
class Solution:
    def findCircleNum(self, M: List[List[int]]) -> int:
        ds = DisjointSet()
        for i in range(len(M)):
            ds.make_set(i)
        for i in range(len(M)):
            for j in range(i+1, len(M)):
                if M[i][j] == 1:
                    ds.union(i, j)
        return ds.num_sets