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

Posted 2021-09-06 英雄哪里出来

🙉饭不食，水不饮，题必须刷🙉
C语言免费动漫教程，和我一起打卡！ 🌞《光天化日学C语言》🌞
LeetCode 太难？先看简单题！ 🧡《C语言入门100例》🧡
数据结构难？不存在的！ 🌳《画解数据结构》🌳
LeetCode 太简单？算法学起来！ 🌌《夜深人静写算法》🌌

文章目录

• 一、题目
• • 1、题目描述
  • 2、基础框架
  • 3、原题链接
• 二、解题报告
• • 1、思路分析
  • 2、时间复杂度
  • 3、代码详解
• 三、本题小知识

一、题目

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]$ 内发生的请求数。

---

三、本题小知识

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

---