高效存储并按多重键排序对象的数据结构

在编写基于优先级队列的Python程序时，需要存储并按多重键对对象进行排序。目前使用SortedList实现了该功能，但需要将此代码扩展，以便使列表按多重键保持排序。

目标是创建一个类似于SQL数据库中具有多列索引的数据结构，以便能够有效地访问、添加和删除所有键的对象。工作负载以添加/删除为主。

2. 解决方案

2.1 方案一

1. 使用堆：
   • 可以使用标准库中的heapq模块，它实现了二叉堆，具有log(n)的插入和删除复杂度，或斐波那契堆，具有O(1)的插入复杂度。
   • 为每个排序顺序维护多个堆，并为每个堆维护一个相应的内容键列表。
   • 使用此技术可以轻松实现O(1)的插入和O(log(n))的删除。

2.2 方案二

1. 多重列表：
   • 为每个排序顺序维护一个内部列表，并在添加/删除项目时维护每个列表。
   • 这种方式仅将数据结构的操作时间乘以一个常量值，即如果使用3个键而不是一个键，则删除/插入一个元素所需的时间为3*log(n)，而不是log(n)。
   • 这种方法与Java的比较器类似，为每个键创建一个比较器方法，并在插入和删除时使用它。

2.3 代码示例：

class SortedList(list):
    def __init__(self, comparator = None):
        list.__init__(self)
        self.comparator = comparator

    def add(self, element):
        index = 0
        while (index < len(self)):
            if self.isGreatterThan(element, self[index]):
                index += 1
            else:
                break
        self.insert(index, element)

    def remove(self, element):
        list.remove(self, element)

    def isGreatterThan(self, element, otherElement):
        if self.comparator != None:
            return self.comparator(element, otherElement)
        else:
            return element.__gt__(otherElement)


class MultipleKeysObjectContainer():
    def __init__(self, comparators):
        self.comparators = comparators
        self.data = {}
        for key in self.comparators.keys():
            self.data[key] = SortedList(comparator = self.comparators[key])

    def add(self, element):
        for key in self.data.keys():
            self.data[key].add(element)

    def __repr__(self):
        return "<MultipleKeysObjectContainer :"+self.data.__repr__()+">"

    def __str__(self):
        result = "MultipleKeysObjectContainer{\n"
        for key in self.data.keys():
            result += "\tOrder by : "+key+"{\n"
            for element in self.data[key]:
                result += "\t\t" + str(element) + "\n"
            result += "\t}\n"
        result += "}"
        return result

    def popOrderedBy(self, key, position):
        item = self.data[key].pop(position)
        for dataKey in self.data.keys():
            if dataKey != key:
                self.data[dataKey].remove(item)

        return item

a = SortedList(lambda x,y : x[0][0] > y[0][0])
item1 = ((1, "z", 1.5),"foo")
item2 = ((2, "a", 40.0), "bar")
item3 = ((3, "f", 0.5), "barfoo")
a.add(item1)
a.add(item3)
a.add(item2)
print("Example of sorted list")
print(a)
a.remove(item3)
print("The same list without the barfoo")
print(a)

b = MultipleKeysObjectContainer({"id": (lambda x,y : x[0][0] > y[0][0]), "letter": (lambda x,y : x[0][1] > y[0][1] ), "value":(lambda x,y : x[0][2] > y[0][2])})

b.add(item1)
b.add(item3)
b.add(item2)
print("A multiple key container, object are ordered according three criterion.")
print(b)
print("Remove the first item if items are ordered by letter", b.popOrderedBy("letter", 0))
print("After this removing the container contains :")
print(b)