四、栈与队列（Stack and Queue）

一、栈(Stack)

栈(stack)，也可以叫做堆栈，是一种容器类型的数据结构，可以存入数据元素、访问元素以及删除元素。
特点：只允许在一端进行操作，采用了后进先出（Last in Fist out）的原理。

Stack

下面采用顺序表的形式来实现栈：

操作	解释
Stack()	创建一个新的栈
push()	在栈中添加一个元素
pop()	弹出栈顶的元素
peek()	返回栈顶的元素
is_empty()	判断这个栈是不是空
size()	栈的大小

class Stack(object):
    """栈"""
    def __init__(self):
        self.__list = []

    def push(self, item):
        """添加一个新元素到栈顶，就是将这个item放到append到最后面"""
        self.__list.append(item)

    def pop(self):
        """弹出栈顶的元素，采用list中的pop方法"""
        return self.__list.pop()

    def peek(self):
        """返回栈顶的元素，就是弹出来最后的一个元素"""
        if self.__list:
            return self.__list[-1]
        else:
            return None

    def is_empty(self):
        """判断栈是不是为空的"""
        return self.__list == []

    def size(self):
        """返回栈的元素个数"""
        return len(self.__list)   

if __name__ == '__main__':
    s = Stack()
    print(s.is_empty()) # True
    print(s.size())     # 0

    s.push(1)
    s.push(2)
    s.push(3)
    print(s.is_empty()) # False
    print(s.peek())     # 3
    print(s.size())     # 3

    s.pop()
    s.pop()
    print(s.is_empty()) # False
    print(s.size())     # 1

二、队列(Queue)

队列是一种只允许在一端进行插入操作，另外一端进行删除操作的线性表
特点是：先进先出（First in First out）。举个例子，就是排队买票去动物园，先排队买到票的小伙伴就先进去。其效果如下图所示：

queue

操作	解释
Queue()	创建一个新的队列
enqueue()	在队列中添加一个元素
dequeue()	从队列的头部删除一个元素
is_empty()	判断这个队列是不是空
size()	队列的大小

class Queue(object):
    """队列"""
    def __init__(self):
        self.__list = []
    
    def enqueue(self, item):
        """往队列中添加一个元素"""
        self.__list.append(item)

    def dequeue(self):
        """将队列头部的一个元素删除"""
        self.__list.pop(0)

    def is_empty(self):
        """判断一个队列是不是空的"""
        return self.__list==[]

    def size(self):
        """返回队列的大小"""
        return len(self.__list)

if __name__ == '__main__':
    q = Queue()
    print(q.is_empty())  # True
    print(q.size())      # 0

    q.enqueue(1)
    q.enqueue(2)
    q.enqueue(3)
    q.enqueue(4)
    print(q.is_empty())  # False
    print(q.size())      # 4

    q.dequeue()
    q.dequeue()
    print(q.is_empty())  # False
    print(q.size())      # 2

三、双端队列(Deque)

双端队列具有队列和栈的数据结构。

操作	解释
Deque()	创建一个空的双端队列
add_front(item)	从队头加入一个item元素
add_rear(item)	从队尾加入一个item元素
remove_front()	从队头删除一个item元素
remove_rear()	从队尾删除一个item元素
is_empty()	判断双端队列是否为空
size()	返回队列的大小

class Deque(object):
    "双端队列"

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

    def is_empty(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)

if __name__ == '__main__':
    deque = Deque()
    deque.add_front(1)
    deque.add_front(2)
    deque.add_rear(3)
    deque.add_rear(4)

    print(deque.size())          # 4
    print(deque.remove_front())  # 2
    print(deque.remove_front())  # 1
    print(deque.remove_rear())   # 4
    print(deque.remove_rear())   # 3

持续更新中...
数据结构与算法系列博客：
一、数据结构与算法概述
二、数组及LeetCode典型题目分析
三、链表（Linked list）以及LeetCode题
四、栈与队列（Stack and Queue
五、树（Trees）
六、递归与回溯算法
七、动态规划
八、排序与搜索
九、哈希表

参考资料：
1、Data Structures and Algorithms in Python [Goodrich, Tamassia & Goldwasser 2013-03-18]
2、https://www.cs.auckland.ac.nz/compsci105s1c/resources/ProblemSolvingwithAlgorithmsandDataStructures.pdf
3、http://interactivepython.org/runestone/static/pythonds/index.html