参考自labuladong的博客

数据结构的存储方式

数据结构的存储方式只有两种：数组（顺序存储）和链表（链式存储）。

数据结构种类很多，散列表、栈、队列、堆、树、图等等，甚至你也可以发明自己的数据结构，但是底层存储无非数组或者链表，二者的优缺点如下：

数组由于是紧凑连续存储,可以随机访问，通过索引快速找到对应元素，而且相对节约存储空间。但正因为连续存储，内存空间必须一次性分配够，所以说数组如果要扩容，需要重新分配一块更大的空间，再把数据全部复制过去，时间复杂度 O(N)；而且你如果想在数组中间进行插入和删除，每次必须搬移后面的所有数据以保持连续，时间复杂度 O(N)。

链表因为元素不连续，而是靠指针指向下一个元素的位置，所以不存在数组的扩容问题；如果知道某一元素的前驱和后驱，操作指针即可删除该元素或者插入新元素，时间复杂度 O(1)。但是正因为存储空间不连续，你无法根据一个索引算出对应元素的地址，所以不能随机访问；而且由于每个元素必须存储指向前后元素位置的指针，会消耗相对更多的储存空间。

栈和队列

栈是一种后进先出的数据结构，元素从顶端入栈，然后从顶端出栈。
队列是一种先进先出的数据结构，元素从后端入队，然后从前端出队。

python 队列

当必须在多个线程之间安全地交换信息时，队列在线程编程中特别有用。

Queue模块的FIFO队列先进先出 class queue.Queue(maxsize)

Queue是python标准库中的线程安全的队列（FIFO）实现，提供了一个适用于多线程编程的先进先出的数据架构，即队列。用来在生产者和消费者线程之间的信息传递

import queue

q = queue.Queue()
# queue.Queue类即是一个队列的同步实现。

q.put(12)
# 调用队列对象的put()方法在队尾插入一个项目。

print(q.get())
# 调用队列对象的get()方法从队头删除并返回一个项目。

常用的方法：

q.qsize()  # 返回队列的大小
q.empty() # 返回队列为空，空为True，反之为False
q.full() # 返回队列是否已经满了,满了返回true，反之False
q.join() # 实际上意味着等到队列为空，在执行别的操作

LIFO类似于堆，即先进后出 class queue.LifoQueue(maxsize)

优先级队列级别越低越先出来。 class queue.PriorityQueue(maxsize)

python 列表实现栈

class MyStack:

    def __init__(self):
        self.num = []

    def push(self, x: int) -> None:
        self.num.append(x)

    def pop(self) -> int:
        return self.num.pop()

    def top(self) -> int:
        return self.num[-1]

    def empty(self) -> bool:
        return len(self.num) == 0

leetcode 225. 用队列实现栈

import queue

class MyStack:

    def __init__(self):
        self.Q1 = queue.Queue()
        self.Q2 = queue.Queue()

    def push(self, x: int) -> None:
        self.Q1.put(x)
        while not self.Q2.empty():
            self.Q1.put(self.Q2.get())
        self.Q1, self.Q2 = self.Q2, self.Q1

    def pop(self) -> int:
        return self.Q2.get()
        
    def top(self) -> int:
        num = self.Q2.get()
        self.push(num)
        return num

    def empty(self) -> bool:
        return self.Q2.qsize() == 0

leetcode 232. 用栈实现队列

# 用两个栈实现队列
class MyQueue:

    def __init__(self):
        self.stack1 = MyStack()
        self.stack2 = MyStack()

    def push(self, x: int) -> None:
        while not self.stack2.empty():
            self.stack1.push(self.stack2.pop())
        self.stack2.push(x)
        while not  self.stack1.empty():
            self.stack2.push(self.stack1.pop())

    def pop(self) -> int:
        return self.stack2.pop()

    def peek(self) -> int:
        return self.stack2.top()

    def empty(self) -> bool:
        return self.stack2.empty()