在给定操作下数组的最大值和最小值之间的最小差

给定一个数组和一些操作（例如添加/删除元素、替换元素等），请设计一个算法以在这些操作下找到数组中最大值和最小值之间的最小差。

一个很自然的想法是：对每个操作都重新遍历一次数组，找到新的最大值和最小值之间的差，然后找最小值。但这种做法时间复杂度很高（O(n*m)，n为数组长度，m为操作数），不适用于大型数据。

更为高效的算法是使用一个数据结构，如堆（heap）或平衡搜索树（balanced search tree），动态地维护数组中的最大值和最小值，并在每个操作后更新它们。这样做可以将时间复杂度降到O(m*log(n))，其中log(n)为堆或平衡搜索树的高度。

以下是使用堆实现的示例代码：

import heapq

class MinMaxHeap:
    def __init__(self, arr):
        self.min_heap = [(val, i) for i, val in enumerate(arr)]
        self.max_heap = [(-val, i) for i, val in enumerate(arr)]
        heapq.heapify(self.min_heap)
        heapq.heapify(self.max_heap)
        self.deleted = set()

    def add(self, val):
        i = len(self.min_heap) - len(self.deleted)
        heapq.heappush(self.min_heap, (val, i))
        heapq.heappush(self.max_heap, (-val, i))

    def delete(self, i):
        self.deleted.add(i)

    def get_min_max_difference(self):
        while self.min_heap[0][1] in self.deleted:
            heapq.heappop(self.min_heap)
        while self.max_heap[0][1] in self.deleted:
            heapq.heappop(self.max_heap)
        return -self.max_heap[0][0] - self.min_heap[0][0]


arr = [3, 1, 5, 2, 4, 6]
heap = MinMaxHeap(arr)

assert heap.get_min_max_difference() == 3

heap.delete(2)
heap.add(7)

assert heap.get_min_max_difference() == 3

在这个示例中，我们使用两个堆分别存储数组中元素的值和它们的索引。当添加元素时，我们在两个堆中同时插入相同的元素，以确保其对应的索引是相同的。当删除元素时，我们只将其对应的索引加入一个集合中，而不是直接从堆中删除。这是因为堆不能高效地删除指定索引的元素，而从堆中弹出元素并在需要时跳过被删除的元素则很容易实现。在计算最大值和最小值之间的最小差时，我们只需要在堆的顶部找到未删除的最大值和最小值，然后计算它们的差。

此外，我们还可以使用一个平衡搜索树，如红黑树（red-black tree）来实现。与堆不同，平衡搜索树可以高效地删除指定元素。以下是使用红黑树实现的示例代码：

import collections

class MinMaxTree:
    def __init__(self, arr):
        self.tree = collections.defaultdict(int)
        self.min = arr[0]
        self.max = arr[0]
        for val in arr:
            self.insert(val)

    def insert(self, val):
        self.tree[val] += 1
        if val < self.min:
            self.min = val
        if val > self.max:
            self.max = val

    def delete(self, val):
        if self.tree[val] > 0:
            self.tree[val] -= 1
            if self.tree[val] == 0:
                del self.tree[val]
            if val == self.min:
                self.min = min(self.tree.keys())
            if val == self.max:
                self.max = max(self.tree.keys())

    def get_min_max_difference(self):
        return self.max - self.min

arr = [3, 1, 5, 2, 4, 6]
tree = MinMaxTree(arr)

assert tree.get_min_max_difference() == 5

tree.delete(5)
tree.insert(7)

assert tree.get_min_max_difference() == 3

在这个示例中，我们使用一个平衡搜索树存储数组中各个元素的个数，并记录当前最大值和最小值。当添加/删除元素时，我们更新对应的计数器并在需要时更新最大值和最小值。在计算最大值和最小值之间的最小差时，我们只需要返回最大值和最小值的差。

综上所述，使用堆或平衡搜索树都可以高效地解决“在给定操作下数组的最大值和最小值之间的最小差”这个问题。具体使用哪个数据结构取决于实际情况，例如是否需要高效删除元素等。