python有排序列表吗？

Question

我的意思是一个结构：

• x.push() 操作的 O(log n) 复杂度
• O(log n) 复杂度找到一个元素
• 计算 list(x) 的 O(n) 复杂度将被排序

我还有一个关于 list(...).insert(...) 的性能的相关问题，现在是 here。

Answer 1

您的 big-O 要求有什么特殊原因吗？或者你只是想让它快点？ sortedcontainers 模块是纯 Python 且速度很快（就像在 blist 和 rbtree 等 fast-as-C 实现中一样）。

performance comparison 显示它的基准测试速度更快或与 blist 的排序列表类型相当。另请注意，rbtree、RBTree 和 PyAVL 提供排序的 dict 和 set 类型，但没有排序的列表类型。

如果性能是一项要求，请始终记住进行基准测试。一个使用 Big-O 表示法证明速度快的模块应该被怀疑，直到它也显示基准比较。

免责声明：我是 Python sortedcontainers 模块的作者。

---

安装：

pip install sortedcontainers

用法：

>>> from sortedcontainers import SortedList
>>> l = SortedList()
>>> l.update([0, 4, 1, 3, 2])
>>> l.index(3)
3
>>> l.add(5)
>>> l[-1]
5

Answer 2

标准的 Python 列表不以任何形式排序。标准的 heapq 模块可用于将 O(log n) 附加到现有列表并删除 O(log n) 中最小的一个，但它不是您定义中的排序列表。

有多种 Python 平衡树实现可以满足您的要求，例如rbtree、RBTree 或 pyavl。

Answer 3

虽然我还没有检查过基本 Python 列表操作的“大 O”速度， 在这种情况下，bisect 标准模块可能也值得一提：

import bisect
L = [0, 100]

bisect.insort(L, 50)
bisect.insort(L, 20)
bisect.insort(L, 21)

print L
## [0, 20, 21, 50, 100]

i = bisect.bisect(L, 20)
print L[i-1], L[i]
## 20, 21

PS。啊，对不起，bisect 在引用的问题中提到。不过，我认为如果这里有这些信息不会有太大的伤害）

PPS。还有CPython lists are actually arrays（不是，比如说，skiplists 等）。嗯，我想它们一定很简单，但对我来说，这个名字有点误导。

---

所以，如果我没记错的话，平分/列表速度可能是：

• 对于 push()：最坏情况的 O(n) ;
• 对于搜索：如果我们认为数组索引的速度为 O(1)，则搜索应该是 O(log(n)) 操作；
• 对于列表的创建：O(n) 应该是列表复制的速度，否则对于同一个列表是 O(1)

更新。在 cmets 讨论之后，让我在这里链接这些 SO 问题：How is Python's List Implemented 和 What is the runtime complexity of python list functions

Answer 4

虽然它没有（还）提供自定义搜索功能，但heapq 模块可能会满足您的需求。它使用常规列表实现堆队列。您必须编写自己的有效成员资格测试，利用队列的内部结构（可以在 O(log n) 中完成，我想说...）。有一个缺点：提取排序列表具有复杂性 O(n log n)。

Answer 5

import bisect

class sortedlist(list):
    '''just a list but with an insort (insert into sorted position)'''
    def insort(self, x):
        bisect.insort(self, x)

Answer 6

我会使用biscect 或sortedcontainers 模块。我真的没有经验，但我认为heapq 模块有效。它包含一个Heap Queue

Answer 7

在 Python 上实现您自己的排序列表可能并不难。下面是一个概念证明：

import bisect

class sortlist:
    def __init__(self, list):
        self.list = list
        self.sort()
    def sort(self):
        l = []
        for i in range(len(self.list)):
            bisect.insort(l, self.list[i])
        self.list = l
        self.len = i
    def insert(self, value):
        bisect.insort(self.list, value)
        self.len += 1
    def show(self):
        print self.list
    def search(self,value):
        left = bisect.bisect_left(self.list, value)
        if abs(self.list[min([left,self.len-1])] - value) >= abs(self.list[left-1] - value):
            return self.list[left-1]
        else:
            return self.list[left]

list = [101, 3, 10, 14, 23, 86, 44, 45, 45, 50, 66, 95, 17, 77, 79, 84, 85, 91, 73]
slist = sortlist(list)
slist.show()
slist.insert(99)
slist.show()
print slist.search(100000000)
print slist.search(0)
print slist.search(56.7)

=========结果============

[3、10、14、17、23、44、45、45、50、66、73、77、79、84、85、86、91、95、101]

[3、10、14、17、23、44、45、45、50、66、73、77、79、84、85、86、91、95、99、101]

101

3

50

Answer 8

AVL 树 [https://en.wikipedia.org/wiki/AVL_tree] 与中序遍历相结合将在所需的时间复杂度内解决此问题。

Answer 9

有趣的案例：如果您的列表 L 已经排序（例如，因为您按排序顺序附加它们），您可以从 O(log n) 中的快速 查找 中受益使用此方法的标准 Python 列表：

import bisect
def in_sorted_list(elem, sorted_list):
    i = bisect.bisect_left(sorted_list, elem)
    return i != len(sorted_list) and sorted_list[i] == elem
L = ["aaa", "bcd", "hello", "world", "zzz"]
print(in_sorted_list("hellu", L))       # False

更多详情请见this answer。