队列

一、概念

队列也是一种”操作受限“的线性表，体现在先进先出原则。

二、常见操作

入队：队列尾部放入数据
出队：队列头部取一个数据

三、常见队列

3.1、普通队列：
1、由于队列是在两端进行操作的，需要两个指针，一个是head指针，指向队头；一个是tail指针，指向队尾。
2、入队的时候就是尾指针向后移动，出队的时候头指针会向后移动。
3、使用数组实现的队列就是顺序队列，使用链表实现的就是链表队列。
4、在顺序队列中，判断队满的条件是tail ==n，队空的条件是head==tail。
5、在顺序队列中，当尾指针指向数组最后一个位置时，入队操作就有问题，此时head由于出队操作已经后移，数组中有位置，为了利用这部分空间，因此出现循环队列，就是让数组首尾相连，当尾指针指向最后一个位置时，再次从数组第一个位置开始，循环队列判断和队空的条件是重点。
6、实际应用中，出现阻塞队列和并发队列。
7、阻塞队列就是给队列增加阻塞机制，入队的时候如果队列满的就会阻塞等待队列有空余位置，出队的时候如果队空就会阻塞等待队列有数据，常应用生产-消费中。

3.2、双端队列：
是一种具有队列的和栈的性质的数据结构。双端队列中的元素可以从两端弹出，其限定插入和删除操作在队列的两端进行。在实际使用中，还可以有输出受限的双端队列（即一个端点允许插入和删除，另一个端点只允许插入的双端队列），输入受限的双端队列（即一个端点允许插入和删除，另一个端点只允许删除的双端队列）。而如果限定双端队列从某个端点插入的元素只能从该端点删除，则该双端队列就蜕变为两个栈底相邻的栈了。

3.3、优先级队列（priority queue）：
1、是0个或多个元素的集合，每个元素都有一个优先权，对优先级队列执行的操作有查找，插入一个新元素或删除。
2、一般情况下，查找操作用来搜索优先权最大的元素，删除操作用来删除该元素。
3、对于优先权相同的元素，可按先进先出次序处理或按任意优先权进行。
4、最突出的优点就是自动排序，本质上是堆实现，故入队和出队的效率都是log（n）,因此也不是线性结构。

四、常见面试题：

1、题目：239. 滑动窗口最大值 https://leetcode-cn.com/problems/sliding-window-maximum/

思路：双端队列

1、遍历数组，while循环判断当前值和队里中的最后一个元素，如果当前值大，则弹出队列中的最后一个值。保证队列中的最左端元素为最大值。

2、保证队列的长度，当超过k-1的长度时，则弹出第一个元素

3、开始加入返回集的条件：数组的下标超过k-1时，则可以返回队列中的最左端的值了。

T：O（n）， S：O（1）

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        res, deque = [], []
        for i in range(len(nums)):
            while deque and nums[i] > nums[deque[-1]]:
                deque.pop()
            deque.append(i)
            while i - deque[0] > k - 1:
                deque.pop(0)
            if i >= k -1:
                res.append(nums[deque[0]])
        return res

2、题目：641. 设计循环双端队列 https://leetcode-cn.com/problems/design-circular-deque/

设计实现双端队列。
你的实现需要支持以下操作：

MyCircularDeque(k)：构造函数,双端队列的大小为k。
insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true。
insertLast()：将一个元素添加到双端队列尾部。如果操作成功返回 true。
deleteFront()：从双端队列头部删除一个元素。 如果操作成功返回 true。
deleteLast()：从双端队列尾部删除一个元素。如果操作成功返回 true。
getFront()：从双端队列头部获得一个元素。如果双端队列为空，返回 -1。
getRear()：获得双端队列的最后一个元素。 如果双端队列为空，返回 -1。
isEmpty()：检查双端队列是否为空。
isFull()：检查双端队列是否满了。
示例：

MyCircularDeque circularDeque = new MycircularDeque(3); // 设置容量大小为3
circularDeque.insertLast(1); // 返回 true
circularDeque.insertLast(2); // 返回 true
circularDeque.insertFront(3); // 返回 true
circularDeque.insertFront(4); // 已经满了，返回 false
circularDeque.getRear(); // 返回 2
circularDeque.isFull(); // 返回 true
circularDeque.deleteLast(); // 返回 true
circularDeque.insertFront(4); // 返回 true
circularDeque.getFront(); // 返回 4

思路：
主要考虑队列中下标的位置。
插入头节点： 先移动下标，后插入值 （front -1 + capacity ）% capacity
插入尾节点： 先插入值，后移动下标 (rear + 1 - capacity) % capacity
删除头节点： （front + 1 - capacity）% capactiy
删除尾节点： （rear - 1）% capacity
得到头节点 ： arr[front]
得到尾节点：arr[rear -1 + capacity] % capacity
是否为空： front == rear
是否满：(rear + 1 - capacity) % capacity == front

class MyCircularDeque:

    def __init__(self, k: int):
        """
        Initialize your data structure here. Set the size of the deque to be k.
        """
        self.front = 0
        self.rear = 0
        self.capacity = k + 1
        self.arr = [0 for _ in range(self.capacity)]

    def insertFront(self, value: int) -> bool:
        """
        Adds an item at the front of Deque. Return true if the operation is successful.
        """
        if self.isFull():
            return False
        self.front = (self.front - 1 + self.capacity) % self.capacity
        self.arr[self.front] = value
        return True

    def insertLast(self, value: int) -> bool:
        """
        Adds an item at the rear of Deque. Return true if the operation is successful.
        """
        if self.isFull():
            return False
        self.arr[self.rear] = value
        self.rear = (self.rear + 1 - self.capacity) % self.capacity
        return True

    def deleteFront(self) -> bool:
        """
        Deletes an item from the front of Deque. Return true if the operation is successful.
        """
        if self.isEmpty():
            return False
        self.front = (self.front + 1 - self.capacity) % self.capacity
        return True

    def deleteLast(self) -> bool:
        """
        Deletes an item from the rear of Deque. Return true if the operation is successful.
        """
        if self.isEmpty():
            return False
        self.rear = (self.rear - 1) % self.capacity
        return True

    def getFront(self) -> int:
        """
        Get the front item from the deque.
        """
        if self.isEmpty():
            return -1
        return self.arr[self.front]

    def getRear(self) -> int:
        """
        Get the last item from the deque.
        """
        if self.isEmpty():
            return -1
        return self.arr[(self.rear - 1 + self.capacity) % self.capacity]

    def isEmpty(self) -> bool:
        """
        Checks whether the circular deque is empty or not.
        """
        return self.front == self.rear

    def isFull(self) -> bool:
        """
        Checks whether the circular deque is full or not.
        """
        return (self.rear + 1 - self.capacity) % self.capacity == self.front

# Your MyCircularDeque object will be instantiated and called as such:
# obj = MyCircularDeque(k)
# param_1 = obj.insertFront(value)
# param_2 = obj.insertLast(value)
# param_3 = obj.deleteFront()
# param_4 = obj.deleteLast()
# param_5 = obj.getFront()
# param_6 = obj.getRear()
# param_7 = obj.isEmpty()
# param_8 = obj.isFull()