数据结构与算法—队列

队列的基本概念

队列是一种先进先出(FIFO)的数据结构，是一种只能在一端进行插入,在另一端进行删除操作的特殊线性表，它按照先进先出的原则存储数据，先进入的数据，在读取数据时先读被读出来。

队列的基本API

python 实现的队列

• 初始化
• 元素入队列
• 元素出队列
• 获取队头元素
• 获取队尾元素
• 判断队列是否为空
• 返回队列中元素个数
• 清空队列

	class Queue:
	    def __init__(self):
	        self._elems = []
	        self.head = 0
	        self.tail = 0
	
	    def en_queue(self, elem):
	        self._elems.append(elem)
	        self.tail += 1
	        return True
	
	    def del_queue(self):
	        if not self.is_empty():
	            value = self.front()
	            self.head += 1
	            return value
	        else:
	            return False
	
	    def front(self):
	        if not self.is_empty():
	            return self._elems[self.head]
	        else:
	            return False
	
	    def rear(self):
	        if not self.is_empty():
	            return self._elems[self.tail - 1]
	        else:
	            return False
	
	    def is_empty(self):
	        if self.head == self.tail:
	            return True
	        else:
	            return False
	    
	    def length(self):
	        return self.tail - self.head
	
	    def clear(self):
	        self.__init__()
	        

循环队列

在循环队列中，当队列为空时，有front=rear，而当所有队列空间全占满时，也有front=rear。为了区别这两种情况，规定循环队列最多只能有MaxSize-1个队列元素，当循环队列中只剩下一个空存储单元时，队列就已经满了。因此，队列判空的条件是front=rear，而队列判满的条件是front=rear+1)%MaxSize。

循环队列的基本API

python 实现的循环队列

• 初始化
• 元素入队列
• 元素出队列
• 获取队头元素
• 获取队尾元素
• 判断队列是否为空
• 判断队列是否满
• 返回队列中元素个数
• 清空队列

	class CircularQueue:
	    def __init__(self, max_size):
	        self._elems = [None for x in range(max_size)]
	        self.max_size = max_size 
	        self.head = 0
	        self.tail = 0
	
	    def en_queue(self, elem):
	        if not self.is_full():
	            self._elems[self.tail] = elem
	            self.tail = (self.tail + 1) % self.max_size
	            return True
	        else:
	            return False
	
	    def del_queue(self):
	        if not self.is_empty():
	            value = self.front()
	            self._elems[self.head] = None
	            self.head = (self.head + 1) % self.max_size
	            return value
	        else:
	            return False
	
	    def front(self):
	        if not self.is_empty():
	            return self._elems[self.head]
	        else:
	            return False
	
	    def rear(self):
	        if not self.is_empty():
	            return self._elems[(self.tail - 1) % self.max_size]
	        else:
	            return False
	
	    def is_empty(self):
	        if self.head == self.tail:
	            return True
	        else:
	            return False
	
	    def is_full(self):
	        if (self.tail + 1) % self.max_size == self.head:
	            return True
	        else:
	            return False
	    
	    def length(self):
	        return (self.tail - self.head + self.max_size) % self.max_size
	
	    def clear(self):
	        self.__init__(self.max_size)
        

队列的常见算法

最近的请求次数(LeetCode933)

写一个 RecentCounter 类来计算最近的请求。
它只有一个方法：ping(int t)，其中 t 代表以毫秒为单位的某个时间。
返回从 3000 毫秒前到现在的 ping 数。
任何处于 [t - 3000, t] 时间范围之内的 ping 都将会被计算在内，包括当前（指 t 时刻）的 ping。
保证每次对 ping 的调用都使用比之前更大的 t 值。
链接：https://leetcode-cn.com/problems/number-of-recent-calls

	class RecentCounter:
	    def __init__(self):
	        self.q = Queue()
	
	    def ping(self, t: int) -> int:
	        self.q.en_queue(t)
	        while self.q.rear() - self.q.front() > 3000:
	            self.q.del_queue()
	        print(self.q.length())