1.栈和队列是在程序设计中被广泛使用的两种线性数据结构，都是在一个特定范围的存储单元中存储的数据，与线性表相比，他们的插入和删除有更多的约束和限定，所以又称为限定性的线性表结构。
2.队列，先进先出（FIFO），栈后进先出（LIFO）
3.实现栈

列表实现栈操作
class MyStack:
    def __init__(self):
        self.item = []

    #判断栈是否为空
    def is_empty(self):
        return len(self.item) == 0

    #返回栈的大小
    def stack_size(self):
        return len(self.item)

    #返回栈顶元素
    def top(self):
        if not self.is_empty():
            return self.item[-1]
        else:
            return None
    #弹栈
    def pop_stack(self):
        if len(self.item) > 0:
            return self.item.pop()
        else:
            print('栈为空')

    #压栈
    def push_stack(self,item):
        self.item.append(item)

if __name__ == '__main__':
    s = MyStack()
    print(s.is_empty())
    s.push_stack(4)
    print(s.stack_size())
    print(s.pop_stack())

链表实现
class Node():
    def __init__(self,x=None):
        self.data = x
        self.next = None

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

    def empty(self):
        if self.next == None:
            return True
        else:
            return False

    def size(self):
        size = 0
        p = self.next
        while p != None:
            p = p.next
            size += 1
        return size

    def push(self,e):
        p= Node()
        p.data = e
        p.next = self.next
        self.next = p

    def pop(self):
        tmp = self.next
        if tmp!=None:
            self.next = tmp.next
            return tmp.data一个
        print('None')

    def top(self):
        if self.next != None:
            return self.next.data
        print('None')

if __name__ == '__main__':
    s = MyStack()
    s.push(1)
    print(s.size())
    print(s.pop())

4.两种方法对比

列表实现栈的优点：一个元素值占用一个空间，他的缺点，初始化申请的空间太大，资源浪费，申请空间太小，后期经常扩充空间，扩充空间是费时操作，会造成性能下降
链表的优点：使用灵活方便，在需要时才会申请空间，缺点为：除了要存储元素外，还需要额外的存储空间存储指针信息
这两种方法时间复杂度都为O（1）