5_队列

5_队列

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

• 队列是一种先进先出的（First In First Out）的线性表，简称FIFO

  

5.1 队列的操作

• 同栈一样，队列也可以用顺序表或者链表实现

操作

• Queue() 创建一个空的队列
• enqueue(item) 往队列中添加一个item元素
• dequeue() 从队列头部删除一个元素
• is_empty() 判断一个队列是否为空
• size() 返回队列的大小

5.1.1 数组实现顺序表代码

class Queue(object):
    '''队列'''
    def __init__(self):
        self.items = []   # 列表的尾端为队列的头
        
    def is_empty(self):
        '''判断是否为空'''
        return self.items==[]
    
    def enqueue(self,item):
        '''进队列'''
        self.items.insert(0,item)
    
    def dequeue(self):
        '''出队列'''
        return self.items.pop()
    
    def size(self):
        '''返回大小'''
        return len(self.items)
if __name__ == '__main__':
    quen = Queue()
    quen.enqueue(1)
    quen.enqueue(2)  
  
    print('是否为空：{}'.format(quen.is_empty()))
    print('链表大小：{}'.format(quen.size()))
    print(quen.dequeue())
    print(quen.dequeue())

5.1.2 链表实现一个链式队列

• 等同于用表尾指针的单链表——链尾入队，链首出队

class Node(object):
    '''定义一个节点'''
    def __init__(self,item,next_=None):
        self.item = item
        self.next = next_

class LQueue(object):
    '''队列'''
    def __init__(self):
        self._head = None
        self._rear = None # 为节点
        
    def is_empty(self):
        '''判断是否为空'''
        return self._head == None
    
    def enqueue(self,item):
        '''进队列'''
        if self.is_empty():
            self._head = Node(item)
            self._rear = self._head
        else:
            self._rear.next = Node(item)
            self._rear = self._rear.next
        
    def dequeue(self):
        '''出队列'''
        if self.is_empty():
            return
        cur = self._head
        self._head = self._head.next
        return cur.item
    
    def peek(self):
        '''查看最早入队的元素'''
        if self.is_empty():
            return
        return self._head.item

if __name__ == '__main__':
    Lquen = LQueue()
    Lquen.enqueue(1)
    Lquen.enqueue(2)   
    print('是否为空：{}'.format(Lquen.is_empty()))
    print('最早入栈的元素为：{}'.format(Lquen.peek()))
    print(Lquen.dequeue())
    print(Lquen.dequeue())

5.1.3 实现一个循环队列

• 【leetcode622】

操作

• MyCircularQueue(k): 构造器，设置队列长度为 k 。
• Front: 从队首获取元素。如果队列为空，返回 -1 。
• Rear: 获取队尾元素。如果队列为空，返回 -1 。
• enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
• deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
• isEmpty(): 检查循环队列是否为空。
• isFull(): 检查循环队列是否已满。

注意：

用直的代替弯的

1. 的到尾部元素时用 rear-1
2. 参考：LeetCode】622. Design Circular Queue 解题报告（Python & C++）

class MyCircularQueue(object):
    '''构造器，设置队列长度为 k '''
    def __init__(self,k):
        self.quene = []
        self.size = k
        self.front = 0   # 指向头部
        self.rear = 0   # 指向尾部
    
    def Front(self):
        ''' 从队首获取元素。如果队列为空,返回 -1'''
        if self.isEmpty():
            return -1
        else:
            return self.quene[self.front]
    
    def Rear(self):
        '''获取队尾元素。如果队列为空，返回 -1'''
        if self.isEmpty():
            return -1
        else:
            return self.quene[self.rear-1]
    
    def enQueue(self,item): 
        '''向循环队列插入一个元素。如果成功插入则返回真'''
        if self.isFull():
            return False
        else:
            self.quene.append(item)
            self.rear += 1
            return True

    def deQueue(self): 
        '''从循环队列中删除一个元素。如果成功删除则返回真'''
        if not self.isEmpty():
            self.front += 1
            return True
        else:
            return False
    
    def isEmpty(self): 
        '''检查循环队列是否为空'''
        return self.quene==[]

    def isFull(self): 
        '''检查循环队列是否已满'''
        return self.rear - self.front ==self.size

if __name__=='__main__':
    Cquene = MyCircularQueue(2)
    Cquene.enQueue(1)
    Cquene.deQueue()
    Cquene.enQueue(2)
    print('获取队首元素:{}'.format(Cquene.Front()))
    print('获取队尾元素:{}'.format(Cquene.Rear()))
    print('是否已满:{}'.format(Cquene.isFull()))
    print('是否为空:{}'.format(Cquene.isEmpty()))
    

5.2 双向队列

• 双端队列（deque，全名double-ended queue），是一种具有队列和栈的性质的数据结构
• 双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队

5.2.1 双向队列操作

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

5.2.2 代码

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('是否为空：{}'.format(deque.is_empty()))
    print('链表大小：{}'.format(deque.size()))
    print('头部删除的元素为：{}'.format(deque.remove_front()))
    print('尾部删除的元素为：{}'.format(deque.remove_rear()))

参考

1. python实现数据结构中的队列