栈，队列，双端队列，

'''
栈
'''


class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

    def __str__(self):
        return str(self.data)


class Stack:
    def __init__(self):
        self._head = None

    # 压栈
    def push(self, item):
        node = Node(item)
        node.next = self._head
        self._head = node
        return node.data

    # 弹栈
    def pop(self):
        if self._head == None:
            return None
        else:
            data = self._head.data
            self._head = self._head.next
            return data

    # peek 取出栈顶元素
    def peek(self):
        if self._head != None:
            return self._head.data
        else:
            raise ValueError('stack is empty')

    def print_all(self):
        cur = self._head
        while cur != None:
            print(cur)
            cur = cur.next


if __name__ == '__main__':
    s = Stack()
    s.push(6)
    s.push(1)
    s.push(8)
    s.push(10)

    s.print_all()

    print('--------pop-------------')
    s.pop()
    s.print_all()

队列：

 class Node:
        def __init__(self, data):
            self.data = data
            self.next = None
    
        def __str__(self):
            return str(self.data)
    
    
    class Queue:
        def __init__(self, maxsize=-1):
            self.maxsize = maxsize
            self._head = None
            self._tail = None
    
        # 入队
        def enter(self, data):  # put
            size = self.qsize()
            if self.maxsize != -1 and self.maxsize > size or self.maxsize == -1:
                node = Node(data)
                if self._head == None and self._tail == None:
                    self._head = node
                    self._tail = node
                else:
                    self._tail.next = node
                    self._tail = node
            else:
                raise Exception('queue full ')
    
        # 出队
        def exit(self):  # get()
            if self._head == None and self._tail == None:
                # return None
                raise ValueError('queue is empty')
            data = self._head.data
            if self._head == self._tail:
                self._head = None
                self._tail = None
            else:
                self._head = self._head.next
            return data
    
        def print_all(self):
            cur = self._head
            while cur != None:
                print(cur)
                cur = cur.next
    
        def qsize(self):
            count = 0
            cur = self._head
            while cur != None:
                count += 1
                cur = cur.next
    
            return count
    
        def full(self):
            pass
    
        def empty(self):
            pass
    
    
    if __name__ == '__main__':
        q = Queue(4)
    
        q.enter(6)
        q.enter(4)
        q.enter(2)
    
        q.print_all()
    print('---------取出-------------')
    q.exit()
    q.print_all()

    print('-----------大小-------')
    q.enter(7)
    q.enter(1)
    # q.enter(9)
    print(q.qsize())

双端队列：

  '''
    双端队列:（deque，全名double-ended queue），是一种具有队列和栈的性质的数据结构。
    双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队。
    '''
    from collections import deque
    
    class Deque:
        def __init__(self):
            self.items = []
    
        def isEmpty(self):
            return self.items == []
    
        def add_front(self, item):
            # 从头部添加
            self.items.insert(0, item)
    
        def add_rear(self, item):
            self.items.append(item)
    
        def remove_front(self):
            return self.items.pop(0)
    
        def remove_rear(self):
            return self.items.pop()
    
        def size(self):
            return len(self.items)
    
        def print_all(self):
            for item in self.items:
                print(item)
    
    
    if __name__ == '__main__':
        dq = Deque()
        dq.add_front(8)
        dq.add_front(9)
        dq.add_front(0)
    
        dq.print_all()
    
        dq.add_rear(6)
        dq.print_all()
    
        print('-----------remove---------')
        dq.remove_front()
    
        dq.print_all()