leetcode 933.最近的请求次数 Java

本文介绍了一个名为RecentCounter的类的设计,该类用于计算特定时间范围内最近的请求次数。通过使用队列数据结构,实现了高效地添加新请求并计算过去3000毫秒内的请求数。

题目链接

https://leetcode-cn.com/problems/number-of-recent-calls/

描述

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

请你实现 RecentCounter 类:

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

提示:

1 <= t <= 104
保证每次对 ping 的调用都使用比之前更大的 t 值
至多调用 ping 方法 104

示例

输入:
["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 = [<u>1</u>, <u>100</u>],范围是 [-2900,100],返回 2
recentCounter.ping(3001);  // requests = [<u>1</u>, <u>100</u>, <u>3001</u>],范围是 [1,3001],返回 3
recentCounter.ping(3002);  // requests = [1, <u>100</u>, <u>3001</u>, <u>3002</u>],范围是 [2,3002],返回 3

初始代码模板

class RecentCounter {

    public RecentCounter() {

    }
    
    public int ping(int t) {

    }
}

/**
 * Your RecentCounter object will be instantiated and called as such:
 * RecentCounter obj = new RecentCounter();
 * int param_1 = obj.ping(t);
 */

代码

这个题目比较难的,就是题目理解。。。
代码一看就懂

class RecentCounter {

    Queue<Integer> queue;

    public RecentCounter() {
        queue = new LinkedList<>();
    }
    
    public int ping(int t) {
        queue.offer(t);
        while (queue.peek() < t - 3000) {
            queue.poll();
        }

        return queue.size();
    }
}

/**
 * Your RecentCounter object will be instantiated and called as such:
 * RecentCounter obj = new RecentCounter();
 * int param_1 = obj.ping(t);
 */
LeetCode 933题“最近请求次数”是一个相对简单的队列应用问题。题目要求实现一个 `RecentCounter` 类,用于统计在最近 3000 毫秒内收到的请求数。每次调用 `ping(t)` 方法时,返回在 `[t - 3000, t]` 时间范围内发生的请求数量。 ### 解法分析 #### 使用队列(Queue)实现 最直接的方法是使用队列来存储每个请求时间戳。当一个新的请求时间 `t` 到达时,首先将该时间加入队列,然后移除所有早于 `t - 3000` 的时间戳。此时队列中的元素个数即为最近 3000 毫秒内的请求数量。 ```python from collections import deque class RecentCounter: def __init__(self): self.queue = deque() def ping(self, t: int) -> int: self.queue.append(t) while self.queue and t - self.queue[0] > 3000: self.queue.popleft() return len(self.queue) ``` 此方法的时间复杂度为 **O(1)**(均摊情况下),空间复杂度为 **O(N)**,其中 N 是最近 3000 毫秒内的请求数量[^2]。 #### Java 实现 同样的逻辑也可以用 Java 实现,使用 `LinkedList` 来模拟队列: ```java import java.util.Queue; import java.util.LinkedList; class RecentCounter { Queue<Integer> myqueue; public RecentCounter() { myqueue = new LinkedList<>(); } public int ping(int t) { while (myqueue.size() > 0 && t - myqueue.peek() > 3000) { myqueue.poll(); } myqueue.add(t); return myqueue.size(); } } ``` #### C++ 实现 C++ 中可以使用标准库中的 `queue` 容器: ```cpp #include <queue> class RecentCounter { public: std::queue<int> que; int ping(int t) { que.push(t); while (!que.empty() && t - que.front() > 3000) { que.pop(); } return que.size(); } }; ``` ### 进阶优化:二分查找 如果请求时间是以递增顺序给出的,还可以考虑使用列表配合二分查找来优化查询过程。每次插入新时间后,使用二分查找找到第一个大于等于 `t - 3000` 的索引,从而快速计算出有效请求数量。 ```python class RecentCounter: def __init__(self): self.pings = [] def ping(self, t): self.pings.append(t) l, r = 0, len(self.pings) target = t - 3000 while l < r: mid = (l + r) // 2 if self.pings[mid] < target: l = mid + 1 else: r = mid return len(self.pings) - l ``` 这种方法的时间复杂度为 **O(log N)**,适用于数据量较大的场景[^5]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值