leetcode队列——933/225/622/641

零、队列常用方法

stack： push 和 pop
queue： offer和 poll
通用的，即二者都可以用的：add、remove

一、933最近的请求次数

1.题目

https://leetcode-cn.com/problems/number-of-recent-calls/
写一个 RecentCounter 类来计算特定时间范围内最近的请求。

请你实现 RecentCounter 类：

RecentCounter() 初始化计数器，请求数为 0 。
int ping(int t) 在时间 t 添加一个新请求，其中 t 表示以毫秒为单位的某个时间，并返回过去 3000 毫秒内发生的所有请求数（包括新请求）。确切地说，返回在 [t-3000, t] 内发生的请求数。
保证 每次对 ping 的调用都使用比之前更大的 t 值。

2.思路

题目看起来很复杂，但其实是考察能不能想到队列以及对队列的应用
题解可以参考官方解答：https://leetcode-cn.com/problems/number-of-recent-calls/solution/zui-jin-de-qing-qiu-ci-shu-by-leetcode/
队列的应用需要巩固熟记

1. 队列分为线性存储和链式存储，常用的是链式存储
   链式存储实现可参考：https://blog.csdn.net/weixin_44963741/article/details/104601175?spm=1001.2101.3001.6650.7&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-7.no_search_link&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-7.no_search_link

2. JAVA集合中的队列
   https://blog.csdn.net/apathecrazyfan/article/details/53082650
   从JDK 1.5开始，java的集合框架提供了一个Queue接口，该接口代表了一个队列。实现该接口或者实现继承了该接口的类可以当做队列来使用。Queue里包含了 6 个方法，用于代表队列

所包含的3个标志性方法，如下所示：
（1）插入：在rear端插入元素。
（2）移除：在front端删除元素。
（3）访问：在front端访问元素。
Java为上面每个方法都提供了两个版本：具有特殊返回值的版本和抛出异常的版本。这样就产生了 6 个方法。关于Queue接口里定义的 6 个方法的说明如下表所示：

3. Linkedlist链表
https://www.runoob.com/java/java-linkedlist.html
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。
LinkedList 继承了 AbstractSequentialList 类。
LinkedList 实现了 Queue 接口，可作为队列使用。
LinkedList 实现了 List 接口，可进行列表的相关操作。
LinkedList 实现了 Deque 接口，可作为队列使用。
LinkedList 实现了 Cloneable 接口，可实现克隆。
LinkedList 实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输。

3.代码

class RecentCounter {
    Queue<Integer> queue;
    public RecentCounter() {
        queue = new LinkedList();
    }
    
    public int ping(int t) {
        queue.add(t);
        while (queue.peek() < t-3000){
            queue.poll();
        }
        return queue.size();

    }
}

二、225 用队列实现栈

1.题目

https://leetcode-cn.com/problems/implement-stack-using-queues/

2.思路

https://www.bilibili.com/video/BV1Y64y1e7SQ?from=search&seid=15629342440424754944&spm_id_from=333.337.0.0
主要集中在push中
用两个队列，辅助队列用于将主队列的队头元素加到队尾，并整体放到主队列中

3.代码

class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2;

    public MyStack() {
        queue1 = new LinkedList<Integer>();
        queue2 = new LinkedList<Integer>();
    }
    
    public void push(int x) {
        //辅助队列先进元素
        queue2.offer(x);
        //主队列不为空
        while(!queue1.isEmpty()){
            queue2.offer(queue1.poll());
        }
        //主队列为空，与辅助队列交换元素
        Queue<Integer> temp = queue1;
        queue1 = queue2;
        queue2 = temp;

    }
    
    public int pop() {
        return queue1.poll();
    }
    
    public int top() {
        return queue1.peek();
    }
    
    public boolean empty() {
        return queue1.isEmpty();
    }
}

三、622 设计循环队列（再多看下）

1.题目

https://leetcode-cn.com/problems/design-circular-queue/solution/she-ji-xun-huan-dui-lie-by-leetcode/
设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

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

2.思路

3.代码

class MyCircularQueue {
    /*
    定义一个数组的总长度，队列的长度，一个数组,队的头结点
    */ 
    private int[] queue;
    private int capity;
    private int count;
    private int Headindex;

    public MyCircularQueue(int k) {
        this.capity = k;
        this.count = 0;
        this.Headindex = 0;
        this.queue = new int[k];

    }
    
    public boolean enQueue(int value) {
        if(this.count == this.capity) return false;
        this.queue[(this.Headindex+this.count)%this.capity] = value;
        this.count +=1;
        return true;

    }
    
    public boolean deQueue() {
        if (this.count == 0) return false;
        this.Headindex = (this.Headindex +1)%this.capity;
        this.count -=1;
        return true;
    }
    
    public int Front() {
        if (this.count == 0) return -1;
        return this.queue[this.Headindex];
    }
    
    public int Rear() {
        if (this.count == 0) return -1;
        int tailIndex = (this.Headindex + this.count -1) % this.capity;
        return this.queue[tailIndex];
    }
    
    public boolean isEmpty() {
        return (this.count ==0);
    }
    
    public boolean isFull() {
        return (this.count == this.capity);
    }
}

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * MyCircularQueue obj = new MyCircularQueue(k);
 * boolean param_1 = obj.enQueue(value);
 * boolean param_2 = obj.deQueue();
 * int param_3 = obj.Front();
 * int param_4 = obj.Rear();
 * boolean param_5 = obj.isEmpty();
 * boolean param_6 = obj.isFull();
 */

四、641 设计循环双端队列

1.题目

2.思路

3.代码