Proto Van Emde蟒蛇树|套装5 |查询：最小，最大

Proto Van Emde蟒蛇树是一种数据结构，用于支持动态集合数据的高效操作。其中的查询操作是最小值和最大值，通过该操作可以在常数时间内找到数据集合中的最小值和最大值。

class ProtoVanEmdeBoasTree:
    def __init__(self, u):
        self.u = u
        self.min = None
        self.max = None
        if u == 2:
            self.clusters = None
            self.leaves = [None, None]
        else:
            self.clusters = [None] * self.sqrtu
            self.summary = ProtoVanEmdeBoasTree(self.sqrtu)
            self.leaves = [ProtoVanEmdeBoasTree(self.sqrtu) for i in range(self.sqrtu)]
        self.sqrtu = int(sqrt(u))

    def high(self, x):
        return x // self.sqrtu

    def low(self, x):
        return x % self.sqrtu

    def index(self, x, y):
        return x * self.sqrtu + y

    def min_value(self):
        return self.min

    def max_value(self):
        return self.max

    def member(self, x):
        if x == self.min or x == self.max:
            return True
        elif self.u == 2:
            return False
        else:
            return self.clusters[self.high(x)] and self.leaves[self.high(x)].member(self.low(x))

    def successor(self, x):
        if self.u == 2:
            if x == 0 and self.max == 1:
                return 1
            else:
                return None
        elif self.min is not None and x < self.min:
            return self.min
        else:
            max_low = self.leaves[self.high(x)].max_value()
            if max_low is not None and self.low(x) < max_low:
                offset = self.leaves[self.high(x)].successor(self.low(x))
                return self.index(self.high(x), offset)
            else:
                succ_cluster = self.summary.successor(self.high(x))
                if succ_cluster is None:
                    return None
                else:
                    offset = self.leaves[succ_cluster].min_value()
                    return self.index(succ_cluster, offset)

    def predecessor(self, x):
        if self.u == 2:
            if x == 1 and self.min == 0:
                return 0
            else:
                return None
        elif self.max is not None and x > self.max:
            return self.max
        else:
            min_low = self.leaves[self.high(x)].min_value()
            if min_low is not None and self.low(x) > min_low:
                offset = self.leaves[self.high(x)].predecessor(self.low(x))
                return self.index(self.high(x), offset)
            else:
                pred_cluster = self.summary.predecessor(self.high(x))
                if pred_cluster is None:
                    if self.min is not None and x > self.min:
                        return self.min
                    else:
                        return None
                else:
                    offset = self.leaves[pred_cluster].max_value()
                    return self.index(pred_cluster, offset)

    def insert(self, x):
        if self.min is None:
            self.min = x
            self.max = x
        else:
            if x < self.min:
                x, self.min = self.min, x
            if self.u > 2:
                if self.leaves[self.high(x)].min_value() is None:
                    self.summary.insert(self.high(x))
                    self.leaves[self.high(x)].min = self.low(x)
                    self.leaves[self.high(x)].max = self.low(x)
                else:
                    self.leaves[self.high(x)].insert(self.low(x))
            if x > self.max:
                self.max = x

    def delete(self, x):
        if self.min == self.max:
            self.min = None
            self.max = None
        elif self.u == 2:
            if x == 0:
                self.min = 1
            else:
                self.min = 0
            self.max = self.min
        else:
            if x == self.min:
                min_cluster = self.summary.min_value()
                x = self.index(min_cluster, self.leaves[min_cluster].min_value())
                self.min = x
            if self.u > 2:
                self.leaves[self.high(x)].delete(self.low(x))
                if self.leaves[self.high(x)].min_value() is None:
                    self.summary.delete(self.high(x))
                    if x == self.max:
                        summary_max = self.summary.max_value()
                        if summary_max is None:
                            self.max = self.min
                        else:
                            self.max = self.index(summary_max, self.leaves[summary_max].max_value())
                elif x == self.max:
                    self.max = self.index(self.high(x), self.leaves[self.high(x)].max_value())

以上是Proto Van Emde蟒蛇树查询最小最大值的代码片段，该代码片段可以用于高效地查找动态数据集合中的最小值和最大值。