⭐算法入门⭐《队列》简单01 —— LeetCode 933. 最近的请求次数

一、题目

1、题目描述

  写一个 RecentCounter 类来计算特定时间范围内最近的请求。实现 RecentCounter类：
   $(1)$ RecentCounter()：初始化计数器，请求数为 0 。
   $(2)$ int ping(int t)：在时间 t 添加一个新请求，其中 t 表示以毫秒为单位的某个时间，并返回过去 3000 毫秒内发生的所有请求数（包括新请求）。确切地说，返回在 [t-3000, t] 内发生的请求数。保证 每次对 ping 的调用都使用比之前更大的 t 值。
  样例输入： ["RecentCounter", "ping", "ping", "ping", "ping"] [[], [1], [100], [3001], [3002]]
  样例输出： [null, 1, 2, 3, 3]

2、基础框架

• C语言版本 给出的基础框架代码如下：

typedef struct {

} RecentCounter;


RecentCounter* recentCounterCreate() {

}

int recentCounterPing(RecentCounter* obj, int t) {

}

void recentCounterFree(RecentCounter* obj) {

}

/**
 * Your RecentCounter struct will be instantiated and called as such:
 * RecentCounter* obj = recentCounterCreate();
 * int param_1 = recentCounterPing(obj, t);
 
 * recentCounterFree(obj);
*/

3、原题链接

$(1)$ LeetCode 933. 最近的请求次数
$(2)$ 剑指 Offer II 042. 最近请求次数

二、解题报告

1、思路分析

  这里其实是需要设计一种容器，由于给出的时间都是单调递增的，所以，如果我们能够保持这个单调性，在某个时间点的请求来的时候，就可以将超过 3000 的请求按顺序剔除。
  而这正好符合 先进先出 的性质。于是，只要用一个队列来维护每个请求，每次请求过来，入队，然后判断 队首元素 和 当前入队元素 时间差 是否超过 3000，超过的 出队。

2、时间复杂度

• 任何一个元素只会在每个队列中 入队 和 出队 各一次，每次操作的时间复杂度为 $O(1)$。

3、代码详解

struct Data {
    int time;                                        // (1) 
};

/**************************** 链表 实现队列 ****************************/
#define DataType struct Data
#define maxn 100005

struct QueueNode;

struct QueueNode {
    DataType data;
    struct QueueNode *next;
};

struct Queue {
    struct QueueNode *head, *tail;
    int size;
};

void QueueEnqueue(struct Queue *que, DataType dt) {
    struct QueueNode *insertNode = (struct QueueNode *) malloc( sizeof(struct QueueNode) );
    insertNode->data = dt;
    insertNode->next = NULL;
    if(que->tail) {
        que->tail->next = insertNode;
        que->tail = insertNode;
    }else {
        que->head = que->tail = insertNode;
    }
    ++que->size;
}

void QueueDequeue(struct Queue* que) {
    struct QueueNode *delNode = que->head;
    que->head = delNode->next;
    free(delNode);
    --que->size;
}

DataType QueueGetFront(struct Queue* que) {
    return que->head->data;
}
int QueueGetSize(struct Queue* que) {
    return que->size;
}
int QueueIsEmpty(struct Queue* que) {
    return !QueueGetSize(que);
}
void QueueClear(struct Queue* que) {
    que->head = que->tail = NULL;
    que->size = 0;
}

/**************************** 链表 实现队列 ****************************/
typedef struct {
    struct Queue q;                     // (2) 
} RecentCounter;


RecentCounter* recentCounterCreate() {
    RecentCounter *rc = (RecentCounter *) malloc (sizeof(RecentCounter));
    QueueClear( &rc->q );
    return rc;
}

int recentCounterPing(RecentCounter* obj, int t) {
    DataType dt, front;
    struct Queue *q = &obj->q;          // (3) 
    dt.time = t;
    QueueEnqueue(q, dt);                // (4) 
    while( !QueueIsEmpty(q) ) {         // (5) 
        front = QueueGetFront(q);       // (6) 
        if(t - front.time > 3000) {     // (7) 
            QueueDequeue(q);
        }else {
            break;                      
        }
    } 
    return QueueGetSize(q);             // (8) 
}

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

• $(1)$ 队列的数据元素就是一个时间戳；
• $(2)$ 计数器只需要维护一个带时间戳的队列；
• $(3)$ 取队列的地址，方便调用队列相关函数时做形参；
• $(4)$ 执行入队操作；
• $(5)-(6)$ 如果 队列 非空，取 队首 的记录；
• $(7)$ 如果队列头的记录和当前的记录相差超过 3000，直接出队，否则跳出循环；
• $(8)$ 当前队列中的元素个数必然是在区间 $[t-3000,t]$ 内发生的请求数。

---

三、本题小知识

   实现队列的方法一般有两种：数组实现、链表实现，本文采用的是链表实现。

---

四、加群须知

  相信看我文章的大多数都是「 大学生 」，能上大学的都是「 精英 」，那么我们自然要「 精益求精 」，如果你还是「 大一 」，那么太好了，你拥有大把时间，当然你可以选择「 刷剧 」，然而，「 学好算法 」，三年后的你自然「 不能同日而语 」。
  那么这里，我整理了「 几十个基础算法 」 的分类，点击开启：

《算法入门指引》
  如果链接被屏蔽，或者有权限问题，可以私聊作者解决。

  大致题集一览：





  为了让这件事情变得有趣，以及「 照顾初学者 」，目前题目只开放最简单的算法 「 枚举系列 」 （包括：线性枚举、双指针、前缀和、二分枚举、三分枚举），当有 一半成员刷完 「 枚举系列 」 的所有题以后，会开放下个章节，等这套题全部刷完，你还在群里，那么你就会成为「 夜深人静写算法 」专家团 的一员。
  不要小看这个专家团，三年之后，你将会是别人 望尘莫及 的存在。如果要加入，可以联系我，考虑到大家都是学生， 没有「 主要经济来源 」，在你成为神的路上，「 不会索取任何 」。
  联系作者，或者扫作者主页二维码加群，加入刷题行列吧

---

让天下没有难学的算法
C语言免费动漫教程，和我一起打卡！ 《光天化日学C语言》
入门级C语言真题汇总 《C语言入门100例》
几张动图学会一种数据结构 《画解数据结构》
组团学习，抱团生长 《算法入门指引》
竞赛选手金典图文教程 《夜深人静写算法》