栈

"""
栈(stack)
    概念1：内存当中的栈区，函数的临时变量之类的都是存储在栈区里边的
    概念2：数据结构，先入后出， last in first out， LIFO
操作：
    push
    pop
"""


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


class CircularDoublyLinkedList(object):

    def __init__(self, max_size=None):
        self.max_size = max_size  # None 表示无限长度
        node = Node()
        node.next, node.prev = node, node  # 根节点自己实现闭环
        self.root = node
        self.length = 0  # root节点不计算在链表的长度中

    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 Exception('full')

        node = Node()
        tailnode = self.tail_node()

        tailnode.next = node
        node.prev = tailnode
        node.next = self.root
        self.root.prev = node
        node.value = value

        self.length += 1

    def append_left(self, value):
        if self.max_size is not None and len(self) > self.max_size:
            raise Exception('full')
        node = Node(value=value)

        if self.root.next is self.root:  # 链表为空
            self.root.next = node
            self.root.prev = node
            node.next = self.root
            node.prev = self.root
        else:
            headnode = self.root.next
            self.root.next = node
            node.next = headnode
            headnode.prev = node
            node.prev = self.root

        self.length += 1

    def remove(self, node):  # 入参 node 而不是 value
        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

        cur_node = self.root.next
        while cur_node is not self.root:
            yield cur_node
            cur_node = cur_node.next
        # yield cur_node

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

    def iter_node_reverse(self):
        if self.root.next is self.root:
            return

        cur_node = self.root.prev
        while cur_node.prev is not self.root:
            yield cur_node
            cur_node = cur_node.prev
        yield cur_node

    def insert(self, value, new_value):
        for node in self.iter_node():
            if node.value == value:
                new_node = Node(value=new_value)
                new_node.next = node
                new_node.prev = node.prev
                node.prev.next = new_node

                node.prev = new_node
                break


class FullQueueError(Exception):
    pass


class EmptyQueueError(Exception):
    pass


class Deque(CircularDoublyLinkedList):
    def pop(self):
        if len(self) <= 0:
            raise EmptyQueueError('空栈')

        tail_node = self.tail_node()
        value = tail_node.value
        self.remove(tail_node)
        return value

    def pop_left(self):
        if len(self) <= 0:
            raise EmptyQueueError('空栈')
        head_node = self.head_node()
        value = head_node.value
        self.remove(head_node)
        return value


class MyStack():
    def __init__(self):
        self._deque = Deque()

    def push(self, value):
        return self._deque.append(value=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_mystack():
    s = MyStack()
    for i in range(3):

'''
栈溢出：stack over flow
    栈区的空间是一定的
    原因一：递归过深，每一次递归，局部变量压一次栈，导致栈区空间用完
    二：局部变量太大
    解决方法：
        增加栈区空间
        使用堆空间
'''