有没有办法找到嵌套列表中的所有并集，以便结果是一个嵌套列表，其中没有列表具有公共元素？

我有一个返回嵌套列表的函数，例如 [[1,2]、[2,3]、[5,6]]。为了查找嵌套列表中的所有并集，我尝试使用集合并集，但我不确定如何在循环中进行过滤，因为嵌套列表的大小不是恒定的。
有没有办法通过列表理解或嵌套 for 循环？

例子：

给定输入 [[1,2], [2,3], [5,6]] --> 输出将是 [[1,2,3], [5,6]]

[[0], [2, 5, 6], [1, 3, 5], [2, 4], [3, 5], [1, 2, 4], [1]] --> [[ 0], [1,2,3,4,5,6]]

您可以使用不相交集数据结构 https://en.wikipedia.org/wiki/Disjoint-set_data_structure。该数据结构支持两种操作：

• Union，我们在数据结构中获取两个成员，并将这些元素（以及它们各自集合中的所有其他成员）分配给同一个不相交集合（本质上，union成员所属的两个集合）。
• Find，它有效地查找元素属于哪个不相交集。我们在最后使用它来将分组读入列表列表中。

其运行时间与不规则列表中的元素总数（几乎）呈线性关系。

这是一个纯Python实现：

class DisjointSets:
    def __init__(self, n):
        self.elements = [-1] * n

    def union(self, first, second):
        first_root, second_root = self.find(first), self.find(second)
        if first_root == second_root:
            return False
        elif first_root < second_root:
            self.elements[first_root] += self.elements[second_root]
            self.elements[second_root] = first_root
            return True
        else:
            self.elements[second_root] += self.elements[first_root]
            self.elements[first_root] = second_root
            return True

    def find(self, target):
        if self.elements[target] < 0:
            return target
        self.elements[target] = self.find(self.elements[target])
        return self.elements[target]
        
data = [[0], [2, 5, 6], [1, 3, 5], [2, 4], [3, 5], [1, 2, 4], [1]] 

# Map elements in the data list to indices
# in the list of the disjoint sets data structure.
item_indices = {}
idx = 0
for sublist in data:
    for item in sublist:
        if item not in item_indices:
            item_indices[item] = idx
            idx += 1

# Bind every element in a sublist to a disjoint set.
# If the element has been seen previously, the data structure
# will correctly union the sets across the sublists.
disjoint_sets = DisjointSets(len(item_indices))
for sublist in data:
    for item1, item2 in zip(sublist, sublist[1:]):
        disjoint_sets.union(item_indices[item1], item_indices[item2])

# Read off the resulting groups.
result = {}
for item in item_indices:
    group_id = disjoint_sets.find(item_indices[item])
    if group_id not in result:
        result[group_id] = []
    result[group_id].append(item)

print(list(result.values()))

这段代码有点长，但好处是它不需要依赖项。如果你想要更简洁的东西，networkx有一个可供您使用的不相交集数据结构的实现。