06_数据结构与算法_双端队列_Python实现

#Created By: Chen Da

"""
思路：
    先实现一个双端链表；
    继承双端链表：
    实现O(1)复杂度下的append、appendleft、pop、popleft方法
"""

#先实现一个双端链表
class Node(object):
    def __init__(self,prev=None,value=None,next=None):
        self.value,self.next = value,next

class FullError(Exception):
    pass

class CircualDoubledLinkedList(object):
    def __init__(self,max_size=None):
        self.max_size = max_size
        node = Node()
        node.prev,node.next = node,node
        self.root = node
        self.length = 0

    def __len__(self):
        return self.length

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

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

    def append(self,value):
        if self.max_size is not None and len(self) > self.max_size:
            raise FullError("The CircualDoubledLinkedList is Full!")
        node = Node(value=value)
        tail_node = self.tail_node()
        tail_node.next = node
        node.prev = tail_node
        node.next = self.root
        self.prev = node
        self.length += 1

    def append_left(self,value):
        if self.max_size is not None and len(self) > self.max_size:
            raise FullError("The CircualDoubledLinkedList is Full!")
        node = Node(value=value)
        if self.root.next is self.root:
            self.root.next = node
            self.root.prev = node
            node.prev = self.root
            node.next = self.root
        else:
            head_node = self.head_node()
            head_node.prev = node
            node.next = head_node
            self.root.next = node
            node.prev = self.root
        self.length += 1

    def remove(self,node):
        if node is self.root:
            return
        else:
            node.prev.next = node.next
            node.next.prev = node.prev
        self.length -= 1
        return node

    def iter_node(self):
        if self.root.next is self.root:
            return
        curr_node = self.root.next
        while curr_node.next is not self.root:
            yield curr_node
            curr_node = curr_node.next
        yield curr_node

    def iter_node_rev(self):
        if self.root.prev is self.root:
            return
        curr_node = self.root.prev
        while curr_node.prev is not self.root:
            yield curr_node
            curr_node = curr_node.prev
        yield curr_node


#############################
#实现Deque
#############################

class EmptyError(Exception):
    pass

class Deque(CircualDoubledLinkedList):

    def pop(self):
        if len(self) == 0:
            raise EmptyError("The Deque is Empty!")
        tail_node = self.tail_node()
        value = tail_node.value
        self.remove(tail_node)
        return value

    def pop_left(self):
        if len(self) == 0:
            raise EmptyError("The Deque is Empty!")
        head_node = self.head_node()
        value = head_node.value
        self.remove(head_node)
        return value


def test_deque():
    size = 5
    dq = Deque(size)        
    for i in range(size):
        dq.append(i)

    assert len(dq) == 5
    assert dq.pop() == 0
    assert dq.pop_left == 4
    
if __name__ == "__main__":
    test_deque()