QUEUE的链表实现[关闭]答案

【问题标题】：Linked list implementation for a QUEUE [closed]QUEUE的链表实现[关闭]
【发布时间】：2013-03-28 12:01:07
【问题描述】：

这是我使用双向链表的队列实现：

QUEUE-EMPTY
if L.head == NIL
    return True
else return False

QUEUE(x):
if L.head == NIL:
    x.prev = NIL
    L.head = x
else
    cur = L.head
    while cur.next != NIL
        cur = cur.next
    cur.next = x
    x.prev = cur
    x.next = NIL

DEQUEUE():
x = L.head
L.head = x.next
x.next.prev = L.head
return x

如何改进？对吗？

有没有办法让 QUEUE O(1) ？

谢谢！！

【问题讨论】：

听起来不像是Stack Overflow 的问题。也许听起来像Code Review 的问题。另外，您希望 O(1) 进行哪些操作？队列与它们一样快，当您希望某些操作比它们更快时，您可能需要另一个数据结构。
当您将一个空队列出队时，您的队列会发生什么情况？如果保留指向列表最后一个节点的指针，QUEUE 的复杂性是多少？

标签： algorithm linked-list queue pseudocode

【解决方案1】：

请参阅下面的更改 + cmets：

QUEUE(x):
if L.head == NIL:
    x.prev = x.next = NIL // otherwise you never set up next
    L.head = x
else
    cur = L.head
    while cur.next != NIL
        cur = cur.next
    cur.next = x
    x.prev = cur
    x.next = NIL

DEQUEUE():
// handle empty queue
if L.head == NIL:
    ERROR! // or something
else
    x = L.head
    L.head = x.next
    if x.next != NIL: // handle empty queue
        x.next.prev = L.head NIL // otherwise it points to itself
    return x

要使QUEUE(x) O(1)，你需要保留一个指向尾部的指针。

QUEUE(x):
if L.head == NIL:
    x.prev = NIL
    L.head = L.tail = x
else
    cur = L.tail
    cur.next = L.tail = x
    x.prev = cur
    x.next = NIL

DEQUEUE():
if L.head == NIL:
    ERROR! // or something
else
    x = L.head
    L.head = x.next
    if x.next != NIL:
        x.next.prev = NIL
    else
        L.tail = NIL
    return x

此外，您实际上并不需要双链表。单链表应该可以正常工作（除非您还想支持其他操作）。

【讨论】：

【解决方案2】：

队列有两种标准实现。

环形缓冲区可以存储在数组中，带有指向头部和尾部的指针。所有算术都是以数组的长度为模完成的。如果尾部赶上头部，队列已经溢出，不能再使用了。

另一种实现使用两个链表。第一个列表是队列的最前面，按顺序排列；第二个列表是队列的后面，以相反的顺序。项目被添加到第二个列表并从第一个列表中检索。每当第一个列表为空并且要获取一个项目时，第二个列表就会反转并成为第一个列表，并创建一个新的（空的）第二个列表。

两种实现的插入和获取/删除时间复杂度为 O(1)。环形缓冲区实现具有绝对时间复杂度 O(1)，但预定义了队列的最大大小。假设有足够的可用内存，链表实现的平均时间复杂度为 O(1)，但对队列的最大大小没有限制。

【讨论】：