python 实现双端队列

Posted 2021-02-09 DRQ丶

# 队列两端都可以进行push和pop操作。 push操作可以用循环双端队列的append，appendleft。
# pop操作使用循环双端队列的romove

class Node(object): # 结点有两个指针
    def __init__(self, maxsize = None, value = None, next = None, prev = None):
        self.maxsize = maxsize
        self.value = value
        self.next = next
        self.prev = prev


class Dqueue(object):
    def __init__(self, maxsize = None):
        self.maxsize = maxsize
        node = Node()
        node.next = node
        node.prev = node # 最开始的只有根结点，它自己两个指针指向自己
        self.root = node
        self.length = 0


    def __len__(self):
        return self.length


    def headnode(self):
        return self.root.next

    def tailnode(self):
        return self.root.prev



    def push(self, value):    # 在右端压入值，相当于循环双端链表的append
        if self.maxsize is not None and len(self) >= self.maxsize:
            raise Exception(‘full‘)
        node = Node(value = value)
        tailnode = self.tailnode() # 获取尾结点， 这个这次append 是插入的第一个结点。 尾结点就是self.root (根结点)
        tailnode.next = node
        node.prev = tailnode
        node.next = self.root
        self.root.prev = node
        self.length += 1


    def pushleft(self, value):
        if self.maxsize is not None and len(self) >= self.maxsize:
            raise Exception(‘full‘)

        node = Node(value = value)
        if self.root.next == self.root:  # 最初只有一个根结点的情况
            self.root.next = node
            self.root.prev = node
            node.next = self.root
            node.prev = self.root
        else:
            head = self.root.next
            node.next = head
            node.prev = self.root
            self.root.next = node
            head.prev = node

        self.length += 1


    def remove(self, node):       # 注意这里传入的是一个node， 不是传入一个值。 为了，降低算法复杂度
        if node is self.root:
            return "不能移除根结点"

        node.prev.next = node.next
        node.next.prev = node.prev
        self.length -= 1
        del node


    def iter_node(self):     #  遍历结点
        if self.root.next == self.root: # 只有根结点
            return "队列为空"

        curnode = self.root.next
        while curnode.next is not self.root:
            yield curnode
            curnode = curnode.next
        yield curnode    # 尾结点也要遍历


    def __iter__(self):
        for node in self.iter_node():
            yield node.value


    def iter_node_reverse(self): # 反向遍历
        if self.root.prev is self.root:
            return

        curnode = self.root.prev    # tailnode
        while curnode.prev is not self.root:
            yield curnode
            curnode =  curnode.prev
        yield curnode


    def pop(self):
        tailnode = self.tailnode()
        self.remove(tailnode)


    def popleft(self):
        head = self.headnode()
        self.remove(head)




def test_Dqueue():  # 测试函数 就测试了主要的pop和push
    dq = Dqueue()
    dq.push(1)
    dq.push(2)
    assert len(dq) == 2
    assert list(dq) == [1,2]
    dq.pushleft(3)
    assert list(dq) == [3,1,2]
    dq.pop()
    assert list(dq) == [3,1]
    dq.popleft()
    assert list(dq) == [1]