Python中的双端队列如何实现？何时比列表差？

Question 1

最近，我开始研究如何在Python中实现各种数据结构，以使我的代码更高效。在研究列表和双端队列的工作方式时，我发现，我想转移和取消移位，可以将列表中的O（n）减少到双端队列的O（1）的时间（列表实现为具有每次在前面插入东西时都可以完全复制，等等。）。我似乎找不到关于如何实现双端队列的细节，以及其缺点与列表的细节。有人可以启发我解决这两个问题吗？

Question 2

https://github.com/python/cpython/blob/v3.8.1/Modules/_collectionsmodule.c

Adequeobject由block节点的双向链接列表组成。

因此，deque是的，另一个答案表明，a是一个（双链接）列表。

详细说明：这意味着Python列表对于随机访问和固定长度的操作（包括切片）要好得多，而双端队列在将内容推入和弹出两端时更有用，因为索引（但不是切片）可能但比列表慢。

Question 3

结帐collections.deque。从文档：

双端队列从双端队列的任一侧支持线程安全，内存高效的追加和弹出，并且在任一方向上的性能都大致相同。

尽管列表对象支持类似的操作，但它们针对快速定长操作进行了优化，并且会为pop（0）和insert（0，v）操作产生O（n）内存移动成本，这会改变基础数据表示的大小和位置。

就像说的那样，使用pop（0）或insert（0，v）会对列表对象造成较大的损失。您不能在上使用切片/索引操作deque，但可以使用popleft/ appendleft，这deque是针对其进行了优化的操作。这是一个简单的基准来证明这一点：

import time
from collections import deque

num = 100000

def append(c):
    for i in range(num):
        c.append(i)

def appendleft(c):
    if isinstance(c, deque):
        for i in range(num):
            c.appendleft(i)
    else:
        for i in range(num):
            c.insert(0, i)
def pop(c):
    for i in range(num):
        c.pop()

def popleft(c):
    if isinstance(c, deque):
        for i in range(num):
            c.popleft()
    else:
        for i in range(num):
            c.pop(0)

for container in [deque, list]:
    for operation in [append, appendleft, pop, popleft]:
        c = container(range(num))
        start = time.time()
        operation(c)
        elapsed = time.time() - start
        print "Completed %s/%s in %.2f seconds: %.1f ops/sec" % (container.__name__, operation.__name__, elapsed, num / elapsed)

我的机器上的结果：

Completed deque/append in 0.02 seconds: 5582877.2 ops/sec
Completed deque/appendleft in 0.02 seconds: 6406549.7 ops/sec
Completed deque/pop in 0.01 seconds: 7146417.7 ops/sec
Completed deque/popleft in 0.01 seconds: 7271174.0 ops/sec
Completed list/append in 0.01 seconds: 6761407.6 ops/sec
Completed list/appendleft in 16.55 seconds: 6042.7 ops/sec
Completed list/pop in 0.02 seconds: 4394057.9 ops/sec
Completed list/popleft in 3.23 seconds: 30983.3 ops/sec

Question 4

我怀疑，deque对象的文档条目阐明了您需要了解的大多数内容。引号：

双端队列从双端队列的任一侧支持线程安全，内存高效的附加和弹出操作，并且在任一方向上的性能大致相同。

但...

索引访问在两端均为O（1），但在中间降低为O（n）。为了快速随机访问，请改用列表。

我不得不看一下源代码，以了解该实现是链接列表还是其他内容，但是在我看来，它似乎deque具有与双向链接列表大致相同的特征。

Question 5

除了所有其他有用的答案之外，这里还有一些其他信息，用于比较Python列表，双端队列，集合和词典上各种操作的时间复杂度（Big-Oh）。这应该有助于为特定问题选择正确的数据结构。

Question 6

虽然我不确定Python是如何实现的，但在这里我仅使用数组编写了Queues的实现。它的复杂度与Python的Queues相同。

class ArrayQueue:
""" Implements a queue data structure """

def __init__(self, capacity):
    """ Initialize the queue """

    self.data = [None] * capacity
    self.size = 0
    self.front = 0

def __len__(self):
    """ return the length of the queue """

    return self.size

def isEmpty(self):
    """ return True if the queue is Empty """

    return self.data == 0

def printQueue(self):
    """ Prints the queue """

    print self.data 

def first(self):
    """ Return the first element of the queue """

    if self.isEmpty():
        raise Empty("Queue is empty")
    else:
        return self.data[0]

def enqueue(self, e):
    """ Enqueues the element e in the queue """

    if self.size == len(self.data):
        self.resize(2 * len(self.data))
    avail = (self.front + self.size) % len(self.data) 
    self.data[avail] = e
    self.size += 1

def resize(self, num):
    """ Resize the queue """

    old = self.data
    self.data = [None] * num
    walk = self.front
    for k in range(self.size):
        self.data[k] = old[walk]
        walk = (1+walk)%len(old)
    self.front = 0

def dequeue(self):
    """ Removes and returns an element from the queue """

    if self.isEmpty():
        raise Empty("Queue is empty")
    answer = self.data[self.front]
    self.data[self.front] = None 
    self.front = (self.front + 1) % len(self.data)
    self.size -= 1
    return answer

class Empty(Exception):
""" Implements a new exception to be used when stacks are empty """

pass

在这里，您可以使用一些代码对其进行测试：

def main():
""" Tests the queue """ 

Q = ArrayQueue(5)
for i in range(10):
    Q.enqueue(i)
Q.printQueue()    
for i in range(10):
    Q.dequeue()
Q.printQueue()    


if __name__ == '__main__':
    main()

它不能像C实现那样快，但是它使用相同的逻辑。