（三）栈与队列

1.栈

1.1.栈的定义

栈（stack）也称堆栈，是一种容器，可以存入数据元素、访问元素、删除元素，它的特点在于只能允许在容器的一端（称为栈顶端指标，top）进行加入数据（push）和输出数据（pop）的运算。

由于栈数据结构只允许在一端进行操作，因此按照后进先出（LIFO，Last in First Out）的原理运作。

栈可以用顺序表实现也可以用链表实现。

1.2栈的实现

栈可以用顺序表实现，也可以用链表实现

• 栈的操作

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

• 代码实现

class Stack(object):
    """栈"""
    def __init__(self):
        self._list=[]
        
	def push(self,item):
        """添加元素到栈顶"""
        self.__list.append(item)
        
    def pop(self):
        """弹出栈顶元素"""
        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==[]
        # return not self.__list
        
    def size(self):
        """返回栈的个数"""
        return len(self.__list)
    
 if __name__=="__main__"  :
    s=Stack()
    s.push(1)
    s.push(2)
    s.push(3)
    print(s.pop())
    print(s.pop())
    print(s.pop())    

1.3栈的应用

• 表达式的求值

  表达式：由运算对象（操作数），运算符（操作符）及分界符组成

  较复杂运算的编译处理

  • 原则：将运算分为若干等级（优先级），优先数大者优先处理；优先数相同者按出现的先后次序处理。

• 递归和过程嵌套

2. 队列

2.1 队列的定义

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作。

队列可以用顺序表实现，也可以用链表实现

2.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()
          
      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__"  :
      s=Queue()
      s.enqueue(1)
      s.enqueue(2)
      s.enqueue(3)
      print(s.dequeue())
      print(s.dequeue())
      print(s.dequeue())     
  

2.3. 双端队列

2.3.1定义

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

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

2.3.2 实现

• 操作

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

• 实现

class Deque(object):
    """双端队列"""
    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 pop_front(self):
        """从队列头部删除一个元素"""
        return self.__list.pop(0)  
   def pop_rear(self):
        """从队列尾部删除一个元素"""
        return self.__list.pop()
    
    def is_empty(self):
        """判断一个队列是否为空"""
        return self.__list==[]
    def size(self):
        """返回队列的大小"""
        return len(self.__list)
    if __name__=="__main__"  :
    s=Deque()
    s.add_front(1)
    s.add_front(2)
    s.add_front(3)
    print(s.pop_front())
    print(s.pop_front())
    print(s.pop_front()) 

2.4 队列的应用

• 计算机主机与外部设备间速度不匹配的问题
• 多用户资源竞争问题