Python 高效的数据结构，使对象按多个键排序

我有一个python程序，其中我使用优先级队列来跟踪要处理的对象。目前，队列是使用SortedList实现的，它工作得非常好

但是，我需要扩展这段代码，以便列表在多个键上保持排序。有点像一个SQL数据库，在多列上有索引，所以我可以有效地访问、添加和删除所有键上的对象。我的工作量很重，添加/删除工作量很大。为了了解我想做什么，这里有一些伪代码：

ml = MultiSortedList()
ml.append((1, "z", 1.5), a)
ml.append((2, "a", 40.0), b)
ml.append((3, "f", 0.5), c)

print(ml.sorted(0))
   [((1, "z", 1.5), a),
   ((2, "a", 40.0), b),
   ((3, "f", 0.5), c),]

print(ml.sorted(2))
   [((3, "f", 0.5), c),
   ((1, "z", 1.5), a),
   ((2, "a", 40.0), b)]

print(ml.sorted(2).pop(1)
   (1, "z", 1.5), a)

print(ml.sorted(0))
   [((2, "a", 40.0), b),
   ((3, "f", 0.5), c)]

我不太明白如何有效地做到这一点。当然，我可以为每个不同列的访问对列表进行再次排序，但这太昂贵了。此外，python列表上的

O（n）

delete操作变得很痛苦，因为该列表可能包含数千个对象

---

是否有一个现有的数据结构（最好已经用python实现）可以解决这个问题？如果没有，你能帮我概括一下如何有效地实施这一点吗

您不应该使用排序列表作为优先级队列的实现，而应该使用。例如，二进制堆具有

log（n）

插入和删除。斐波那契堆将有

O（1）

插入

在标准库中有一个实现：模块

对于您的用例，您需要保留多个堆：每个排序顺序一个。为了实现的清晰，您可能希望将原始数据保存在字典上（可能使用随机键或递增键），并且只将其键保留在堆上

---

使用此技术，您可以轻松地获得

O（1）

插入和

O（log（n））

删除。您实际上没有指定要进行的访问类型，但是如果需要随机访问，可以在适当的堆上使用以获得

O（log（n））

一种方法是在内部维护

n

列表，每个排序顺序一个，并为每个排序顺序添加/删除项。 通过这种方式，“仅”将数据结构的操作时间乘以一个常量值（即，如果使用3个键而不是1个键，则使用

3 log（n）

而不是

log（n）

来删除/插入元素）

我想象这种实现背后的概念是java的Comparator one

为每个键创建一个比较器方法来对它们进行排序，然后在插入和删除时使用它

其工作如下：

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

        self.comparator = comparator

    def add(self, element):
        """ Adds the element into the sorted list.
        If no comparator where provided at initialisation, then try to compare
        the element to item already stored in the list using standard __gt__ 
        and __eq__.

        Argument :
            element : the element to insert in the list

        /!\ NB : A more inteligent implementation should be used, such as binary search... /!\
        """
        index = 0
        while (index < len(self)):
            if self.isGreatterThan(element, self[index]):
                index += 1
            else:
                break

        self.insert(index, element)

    def remove(self, element):
        """ Same as previous, a better approach is possible that use binary search """
        list.remove(self, element)


    def isGreatterThan(self, element, otherElement):
        """ Compare if element is greater than other element. """
        if self.comparator != None:
            return self.comparator(element, otherElement)
        else:
            return element.__gt__(otherElement)


class MultipleKeysObjectContainer():
    def __init__(self, comparators):
        #register the comparators
        self.comparators = comparators
        #create a List for each comparator
        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):
        """ pop the item a the position in the list of item ordered by the key.
        Remove also from other data containers. """
        item = self.data[key].pop(position)
        for dataKey in self.data.keys():
            if dataKey != key:
                self.data[dataKey].remove(item)

        return item



if __name__ == "__main__":
    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)

看起来像您正在寻找的（几乎，只需添加二进制搜索：p）

---

祝你好运

有多少列/不同的字段？这是一个固定的数字吗？为什么不让sql为您这样做呢？如果您在python中寻找sql风格的功能，您是否看过pandas包-？@sasha:大约4-5列。如果这种情况发生变化，我可以重新编写应用程序。在SQL中这样做的问题只是开销。这是一个需要大量访问的数据结构，因此我认为将其实现为在数据库中添加/删除行（以及序列化对象）会有太高的开销。我最终使用了类似的解决方案，使用了一个包装器，可以根据需要从所有堆中插入和删除对象。谢谢你的帮助！

Example of sorted list
[((1, 'z', 1.5), 'foo'), ((2, 'a', 40.0), 'bar'), ((3, 'f', 0.5), 'barfoo')]
The same list without the barfoo
[((1, 'z', 1.5), 'foo'), ((2, 'a', 40.0), 'bar')]
A multiple key container, object are ordered according three criterion.
MultipleKeysObjectContainer{
    Order by : id{
        ((1, 'z', 1.5), 'foo')
        ((2, 'a', 40.0), 'bar')
        ((3, 'f', 0.5), 'barfoo')
    }
    Order by : value{
        ((3, 'f', 0.5), 'barfoo')
        ((1, 'z', 1.5), 'foo')
        ((2, 'a', 40.0), 'bar')
    }
    Order by : letter{
        ((2, 'a', 40.0), 'bar')
        ((3, 'f', 0.5), 'barfoo')
        ((1, 'z', 1.5), 'foo')
    }
}
Remove the first item if items are ordered by letter ((2, 'a', 40.0), 'bar')
After this removing the container contains :
MultipleKeysObjectContainer{
    Order by : id{
        ((1, 'z', 1.5), 'foo')
        ((3, 'f', 0.5), 'barfoo')
    }
    Order by : value{
        ((3, 'f', 0.5), 'barfoo')
        ((1, 'z', 1.5), 'foo')
    }
    Order by : letter{
        ((3, 'f', 0.5), 'barfoo')
        ((1, 'z', 1.5), 'foo')
    }
}