07_数据结构与算法_栈_Python实现

#Created By: Chen Da

"""
    栈区
    LIFO结构

    ADT:
        method:push、pop
"""

#先实现一个双端链表
class Node(object):
    def __init__(self,prev=None,value=None,next=None):
        self.prev,self.value,self.next = prev,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() or self.root
        tail_node.next = node
        node.prev = tail_node
        node.next = self.root
        self.root.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

#############################
#实现栈
#############################

class Stack():
    def __init__(self):
        self.deque = Deque()

    def push(self,value):
        return self.deque.append(value)

    def pop(self):
        return self.deque.pop()

    def __len__(self):
        return len(self.deque)

    def is_empty(self):
        return len(self) == 0


def test_stack():
    s = Stack()
    for i in range(3):
        s.push(i)

    assert len(s) == 3
    assert s.pop() == 2
    assert s.pop() == 1
    assert s.pop() == 0

    assert s.is_empty()

if __name__ == '__main__':
    test_stack()