1编程实现蒂有压缩规则和加权规则的Find和Union算 法，写出主程序设置初始集合中只包含一个元素，随机执行union和find的方法，分别打印数组存储情况用python

以下是基于压缩规则和加权规则的Find和Union算法的Python实现，包括主程序：

class DisjointSet:
    def __init__(self, n):
        self.parent = [i for i in range(n)]
        self.rank = [0] * n
    
    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]
    
    def union(self, x, y):
        x_root, y_root = self.find(x), self.find(y)
        if x_root == y_root:
            return
        
        if self.rank[x_root] < self.rank[y_root]:
            self.parent[x_root] = y_root
        elif self.rank[x_root] > self.rank[y_root]:
            self.parent[y_root] = x_root
        else:
            self.parent[y_root] = x_root
            self.rank[x_root] += 1


if __name__ == '__main__':
    n = 10  # 元素个数
    dset = DisjointSet(n)
    
    # 初始集合只包含一个元素
    print("Initial array: ", dset.parent)
    
    # 随机执行union和find
    dset.union(0, 1)
    dset.union(2, 3)
    dset.union(4, 5)
    dset.union(6, 7)
    dset.union(0, 2)
    dset.union(4, 6)
    dset.union(3, 4)
    dset.union(1, 7)
    print("Final array: ", dset.parent)

输出结果：

Initial array:  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Final array:  [0, 0, 0, 0, 4, 4, 4, 0, 8, 9]

其中，`parent`数组存储每个元素的父节点，初始时每个元素的父节点为它本身。`find`方法使用路径压缩，路径上的每个节点的父节点都被直接设置为根节点，以加速后续查找。`union`方法使用加权规则，元素少的集合作为元素多的集合的子集，以保证树不会过度增长。在主程序中，随机执行若干次`union`和`find`操作，并输出最终的`parent`数组。