LeetCode：2671. 频率跟踪器（双hash Java）

最新推荐文章于 2025-12-18 17:00:31 发布

原创最新推荐文章于 2025-12-18 17:00:31 发布 · 581 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #哈希算法 #java

本文介绍了如何设计和实现一个频率跟踪器数据结构，包括单哈希方法可能导致超时的问题，以及双哈希的优化方案，利用两个数组分别存储数字出现的个数和每个频率的计数，适用于数据范围较小的情况。

2671. 频率跟踪器

题目描述：

请你设计并实现一个能够对其中的值进行跟踪的数据结构，并支持对频率相关查询进行应答。

实现 FrequencyTracker 类：

FrequencyTracker()：使用一个空数组初始化 FrequencyTracker 对象。
void add(int number)：添加一个 number 到数据结构中。
void deleteOne(int number)：从数据结构中删除一个 number 。数据结构 可能不包含 number ，在这种情况下不删除任何内容。
bool hasFrequency(int frequency): 如果数据结构中存在出现 frequency 次的数字，则返回 true，否则返回 false。

示例 1：

输入
["FrequencyTracker", "add", "add", "hasFrequency"]
[[], [3], [3], [2]]
输出
[null, null, null, true]

解释
FrequencyTracker frequencyTracker = new FrequencyTracker();
frequencyTracker.add(3); // 数据结构现在包含 [3]
frequencyTracker.add(3); // 数据结构现在包含 [3, 3]
frequencyTracker.hasFrequency(2); // 返回 true ，因为 3 出现 2 次

示例 2：

输入
["FrequencyTracker", "add", "deleteOne", "hasFrequency"]
[[], [1], [1], [1]]
输出
[null, null, null, false]

解释
FrequencyTracker frequencyTracker = new FrequencyTracker();
frequencyTracker.add(1); // 数据结构现在包含 [1]
frequencyTracker.deleteOne(1); // 数据结构现在为空 []
frequencyTracker.hasFrequency(1); // 返回 false ，因为数据结构为空

示例 3：

输入
["FrequencyTracker", "hasFrequency", "add", "hasFrequency"]
[[], [2], [3], [1]]
输出
[null, false, null, true]

解释
FrequencyTracker frequencyTracker = new FrequencyTracker();
frequencyTracker.hasFrequency(2); // 返回 false ，因为数据结构为空
frequencyTracker.add(3); // 数据结构现在包含 [3]
frequencyTracker.hasFrequency(1); // 返回 true ，因为 3 出现 1 次

提示：

1 <= number <= 105
1 <= frequency <= 105
最多调用 add、deleteOne 和 hasFrequency 共计 2 * 105 次

实现代码与解析：

单hash（超时）

package lt.lt24321.频率跟踪器2671;

import java.util.HashMap;
import java.util.Map;

class FrequencyTracker {

    public Map<Integer, Integer> map;

    public FrequencyTracker() {
        map = new HashMap<>();
    }

    public void add(int number) {
        if (map.containsKey(number)) {
            map.put(number, map.get(number) + 1);
        } else {
            map.put(number, 1);
        }
    }

    public void deleteOne(int number) {
        if (!map.containsKey(number))return;

        int cnt = map.get(number);
        if (cnt == 1) {
            map.remove(number);
        } else {
            map.put(number, cnt - 1);
        }
    }

    public boolean hasFrequency(int frequency) {
        if (map.containsValue(frequency)) return true;
        else return false;
    }
}

所以考虑优化。

双hash

class FrequencyTracker {

    private static final int N = 100001;
    private int[] num;
    private int[] numCnt;

     public FrequencyTracker() {
        num = new int[N];
        numCnt = new int[N];
    }

    public void add(int number) {
        numCnt[num[number]]--; // 去掉原来频次的个数
        num[number]++;
        numCnt[num[number]]++; // 新添后的频次加一
    }

    public void deleteOne(int number) {
        if (num[number] == 0) return ;
        numCnt[num[number]]--; // 去掉原来频次的个数
        num[number]--;
        numCnt[num[number]]++; // 减去后的频次加一

    }

    public boolean hasFrequency(int frequency) {
        return numCnt[frequency] > 0;
    }
}