4-栈+队列+双端队列

一、栈

栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。

向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；

从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

注：由于栈数据结构只允许在一端进行操作，则其先进后出（FILO，First In Last Out）

（1）栈结构实现：栈可以用顺序表实现，也可以用链表实现。【此处使用python中的list（顺序表）实现栈】

（2）栈的操作：Stack() 创建一个新的空栈；push(item) 添加一个新的元素item到栈顶；pop() 弹出栈顶元素；peek() 返回栈顶元素；is_empty() 判断栈是否为空；size() 返回栈的元素个数

class Stack(object):  #栈  【先进后出】
    def __init__(self):
        self.__list=[]  #一个私有的顺序表

    def push(self,item):  #添加一个新的元素item到栈顶
        self.__list.append(item)  #从列表的尾部添加

    def pop(self):  #弹出栈顶元素
        return self.__list.pop()  #从列表的尾部弹出

    def peek(self):  #返回栈顶元素
        if self.__list:
            return self.__list[-1]  #返回栈顶元素
        else:
            return None

    def is_empty(self):  #判断栈是否为空
        return self.__list==[]  #若为空，返回True

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

if __name__ == '__main__':
    s=Stack()
    s.push(1)
    s.push(2)
    s.push(3)
    s.push(4)
    print(s.pop())  #4
    print(s.pop())  #3
    print(s.pop())  #2
    print(s.pop())  #1

二、队列

队列（queue）是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。

进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。 

注：因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表。

（1）队列的实现：队列可以用顺序表实现，也可以用链表实现。【此处使用python中的list（顺序表）实现队列】

（2）队列的操作：Queue()创建一个新的空栈；enqueue(item)往队列中添加一个item元素；dequeue()从队列头部删除一个元素；is_empty()判断队列是否为空；size()返回队列的元素个数

class Queue(object):  #队列 【先进先出】
    def __init__(self):
        self.__list=[]

    def enqueue(self,item):  #往队列中添加一个item元素
        self.__list.append(item)

    def dequeue(self):  #从队列头部删除一个元素
        return self.__list.pop(0)

    def is_empty(self):  #判断队列是否为空
        return self.__list==[]

    def size(self):  #返回队列的元素个数
        return len(self.__list)

if __name__ == '__main__':
    q=Queue()
    q.enqueue(1)
    q.enqueue(2)
    q.enqueue(3)
    q.enqueue(4)
    print(q.dequeue())  #1
    print(q.dequeue())  #2
    print(q.dequeue())  #3
    print(q.dequeue())  #4

三、双端队列

双端队列（deque，全名double-ended queue），是一种具有队列和栈的性质的数据结构。

双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队。

（1）双端对列的实现：双端队列可以用顺序表实现，也可以用链表实现。【此处使用python中的list（顺序表）实现双端队列】

（2）双端队列的操作：Deque()创建一个空的双端对列；add_front(item)从队头加入一个item元素；add_rear(item)从队尾加入一个item元素；remove_front()从队头删除一个元素；remove_rear()从队尾删除一个元素；is_empty()判断双端对列是否为空；size()返回队列的元素个数

class Deque():  #双端对列
    def __init__(self):
        self.__list=[]

    def add_front(self,item):  #从队头加入一个item元素
        self.__list.insert(0,item)

    def add_rear(self,item):  #从队尾加入一个item元素
        self.__list.append(item)

    def remove_front(self):  #从队头删除一个元素
        return self.__list.pop(0)

    def remove_rear(self):  #从队尾删除一个元素
        return self.__list.pop()

    def is_empty(self):  #判断双端对列是否为空
        return self.__list==[]
    def size(self):  #返回队列的元素个数
        return len(self.__list)
if __name__ == '__main__':
    d=Deque()
    d.add_front(1)  #此时d为1
    d.add_rear(2)   #此时d为[1,2]
    d.add_front(3)  #此时d为[3,1,2]
    d.add_rear(4)   #此时d为[3,1,2,4]
    print(d.remove_front())  #3  此时d为[1,2,4]
    print(d.remove_rear())   #4  此时d为[1,2]
    print(d.remove_front())  #1  此时d为[2]
    print(d.remove_rear())   #2  此时d为空的

转载于:https://my.oschina.net/pansy0425/blog/3070849