《五月集训》第十六天——队列

---

前言

        队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
刷题坚持每一天，以下题目引用自：力扣（LeetCode）

💎一、题目一

🏆1.题目描述

原题链接：933. 最近的请求次数

        写一个 RecentCounter 类来计算特定时间范围内最近的请求。
请你实现 RecentCounter 类：

• RecentCounter() 初始化计数器，请求数为 0 。
• int ping(int t) 在时间 t 添加一个新请求，其中 t 表示以毫秒为单位的某个时间，并返回过去 3000 毫秒内发生的所有请求数（包括新请求）。确切地说，返回在 [t-3000, t] 内发生的请求数。

保证 每次对 ping 的调用都使用比之前更大的 t 值。

示例 1：
输入：
[“RecentCounter”, “ping”, “ping”, “ping”, “ping”]
[[], [1], [100], [3001], [3002]]
输出：
[null, 1, 2, 3, 3]
解释：
RecentCounter recentCounter = new RecentCounter();
recentCounter.ping(1); // requests = [1]，范围是 [-2999,1]，返回 1
recentCounter.ping(100); // requests = [1, 100]，范围是 [-2900,100]，返回 2
recentCounter.ping(3001); // requests = [1, 100, 3001]，范围是 [1,3001]，返回 3
recentCounter.ping(3002); // requests = [1, 100, 3001, 3002]，范围是 [2,3002]，返回 3

🏆2.解题思路

🔑思路：

​         每一个新请求都入队，然后再判断队首的的请求时间是否在新请求之后的3000里，不在则出队。

🏆3.代码详解

typedef struct {
    int queue[10001];
    int head;
    int tail;
} RecentCounter;


RecentCounter* recentCounterCreate() {
    RecentCounter* obj = (RecentCounter*)malloc(sizeof(RecentCounter));
    obj->head = 0;
    obj->tail = 0;
    return obj;
}

int recentCounterPing(RecentCounter* obj, int t) {
    obj->queue[obj->tail++] = t;
    while(obj->queue[obj->head] < obj->queue[obj->tail-1]-3000){
        ++obj->head;
    } 
    return obj->tail - obj->head;
}

void recentCounterFree(RecentCounter* obj) {
    free(obj);
}

---

💎二、题目二

🏆1.题目描述

原题链接：2073. 买票需要的时间

        有 n 个人前来排队买票，其中第 0 人站在队伍 最前方 ，第 (n - 1) 人站在队伍 最后方 。
        给你一个下标从 0 开始的整数数组 tickets ，数组长度为 n ，其中第 i 人想要购买的票数为 tickets[i] 。
        每个人买票都需要用掉 恰好 1 秒 。一个人 一次只能买一张票 ，如果需要购买更多票，他必须走到 队尾 重新排队（瞬间 发生，不计时间）。如果一个人没有剩下需要买的票，那他将会 离开 队伍。
        返回位于位置 k（下标从 0 开始）的人完成买票需要的时间（以秒为单位）。

示例 1：
输入：tickets = [2,3,2], k = 2
输出：6
解释：
第一轮，队伍中的每个人都买到一张票，队伍变为 [1, 2, 1] 。
第二轮，队伍中的每个都又都买到一张票，队伍变为 [0, 1, 0] 。
位置 2 的人成功买到 2 张票，用掉 3 + 3 = 6 秒。

🏆2.解题思路

🔑思路：

​         每次买完票都出队，判断k位置的人是否需要买票，不需要返回时间。需要则在入队，直至k位置的人不需要买票；

🏆3.代码详解

typedef struct {
    int queue[10010];
    int head;
    int tail;
} RecentCounter;

int timeRequiredToBuy(int* tickets, int ticketsSize, int k){
    RecentCounter* obj = (RecentCounter*)malloc(sizeof(RecentCounter));
    obj->head = 0;
    obj->tail = 0;
    int time = 0;
    int flag = 0;
    for(int i = 0; i < ticketsSize; ++i){
        obj->queue[obj->tail++] = tickets[i] -= 1;
        ++time;
        if(i == k && tickets[i] == 0) return time;
    }
    while(1){
        obj->queue[obj->head] -= 1;
        obj->queue[obj->tail++] = obj->queue[obj->head];
        if(obj->queue[obj->head] >= 0) ++time;
        if(k == flag && obj->queue[obj->head] == 0) return time;
        ++obj->head;
        ++flag;
        if(flag == ticketsSize){
            flag = 0;
        }
    }
    return;
}

---

💎三、题目三

🏆1.题目描述

原题链接：641. 设计循环双端队列

设计实现双端队列。
实现 MyCircularDeque 类:

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

示例 1：
输入
[“MyCircularDeque”, “insertLast”, “insertLast”, “insertFront”, “insertFront”, “getRear”, “isFull”, “deleteLast”, “insertFront”, “getFront”]
[[3], [1], [2], [3], [4], [], [], [], [4], []]
输出
[null, true, true, true, false, 2, true, true, true, 4]
解释
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

🏆2.解题思路

🔑思路：

​        双端队列是一种具有队列和栈性质的数据结构，即可在线性表的两端进行插入和删除。根据这一性质，在数组的两端，进行数据插入与删除。两端操作如栈一样先进后出。

🏆3.代码详解

typedef struct {
    int* queue;
    int head;
    int tail;
    int queuesize;
} MyCircularDeque;

MyCircularDeque* myCircularDequeCreate(int k) {
    MyCircularDeque* obj = (MyCircularDeque*)malloc(sizeof(MyCircularDeque));
    obj->queue = (int*)malloc(sizeof(int)*k);
    obj->head = -1;
    obj->tail = -1;
    obj->queuesize = k;
    return obj;
}
bool myCircularDequeIsEmpty(MyCircularDeque* obj) {
    return (obj->head == -1) && (obj->tail == -1);
}

bool myCircularDequeIsFull(MyCircularDeque* obj) {
    return ((obj->tail+1) % obj->queuesize) == obj->head;
}

bool myCircularDequeInsertFront(MyCircularDeque* obj, int value) {
    if(myCircularDequeIsFull(obj)) return false;
    if(myCircularDequeIsEmpty(obj)){
        ++obj->head;
        ++obj->tail;
        obj->queue[obj->head] = value;
        return true;
    }
    obj->head = (obj->head - 1 + obj->queuesize) % obj->queuesize;
    obj->queue[obj->head] = value;
    
    return true;
}

bool myCircularDequeInsertLast(MyCircularDeque* obj, int value) {
    if(myCircularDequeIsFull(obj)) return false;
    if(myCircularDequeIsEmpty(obj)){
        ++obj->head;
        ++obj->tail;
        obj->queue[obj->tail] = value;
        return true;
    }
    obj->tail = (obj->tail + 1)  % obj->queuesize;
    obj->queue[obj->tail] = value;
    

    return true;
}

bool myCircularDequeDeleteFront(MyCircularDeque* obj) {
    if(myCircularDequeIsEmpty(obj)) return false;
    if(obj->head == obj->tail){
        obj->head = -1;
        obj->tail = -1;
        return true;
    }
    obj->head =(obj->head + 1) % obj->queuesize;
    return true;
}

bool myCircularDequeDeleteLast(MyCircularDeque* obj) {
    if(myCircularDequeIsEmpty(obj)) return false;
    if(obj->head == obj->tail){
        obj->head = -1;
        obj->tail = -1;
        return true;
    }
    obj->tail = (obj->tail - 1 + obj->queuesize)  % obj->queuesize;
    return true;
}

int myCircularDequeGetFront(MyCircularDeque* obj) {
    if(myCircularDequeIsEmpty(obj)) return -1;
    return obj->queue[obj->head];
}

int myCircularDequeGetRear(MyCircularDeque* obj) {
    if(myCircularDequeIsEmpty(obj)) return -1;
    return obj->queue[obj->tail];
}

void myCircularDequeFree(MyCircularDeque* obj) {
    free(obj->queue);
    free(obj);
}

---

💎四、星球推荐

        星球链接：英雄算法联盟

星球里有什么?
        【朋友圈】一个极致精准的自律、编程、算法的小圈子。
        【算法集训】以月为单位组织算法集训，每天四题，风雨无阻。
        【排行榜】每天、每周都会有榜单，激励大家不断进步，不断成长。
        【个人规划】每个人都写好自己的规划，也可以查看他人的规划，时刻警醒自己不掉队。
        【打卡挑战】每日一题打卡、每日早起打卡、算法集训打卡、规划完成情况打卡。
在星球里做什么?
        目前星球人数达到420+，在星球里你能够遇到一群志同道合之人，因为都是花钱进来的，你不会看到任何浑水摸鱼的人，每个人都有自己的每月规划，星主每月都会组织算法集训，每天一起刷题，你可以看到别人的解题报告，取其之长，补己之短。