2026-06-15：频率唯一的第一个元素。用go语言，从左到右扫描数组，统计每个元素出现的次数。对每个元素判断它的出现频率是否与其他元素不

福大大架构师每日一题

发布于 2026-06-24 15:29:04

1310

2026-06-15：频率唯一的第一个元素。用go语言，从左到右扫描数组，统计每个元素出现的次数。对每个元素判断它的出现频率是否与其他元素不同：也就是它的出现次数在所有元素中是唯一的那种。找到最先满足这种“频率唯一”的元素并返回它；如果没有任何元素满足条件，则返回 -1。

1 <= nums.length <= 100000。

1 <= nums[i] <= 100000。

输入： nums = [20,10,30,30]。

输出： 30。

解释：

20 出现了 1 次。

10 出现了 1 次。

30 出现了 2 次。

30 的出现频率是唯一的，因为没有其他整数恰好出现 2 次。

题目来自力扣3843。

一、整体解题分步详细过程

步骤1：遍历原数组，统计每个数字的出现频次

1. 初始化一个键为数组元素、值为出现次数的哈希映射 cnt，用于记录每个数字出现多少次。
2. 从左到右完整遍历输入数组中每一个数字：
- • 取出当前数字，去哈希映射中查找该数字对应的计数；
- • 若该数字第一次出现，映射内默认计数为0，执行计数+1；若已存在则直接在原有计数基础上+1；
3. 以示例输入 [20,10,30,30] 举例，遍历完成后哈希映射存储结果：
- • 20：出现1次
- • 10：出现1次
- • 30：出现2次

步骤2：统计「频次的频次」，记录每种出现次数有多少个数字

1. 创建数组 cc，数组长度等于原数组长度+1。原因：一个数字最多完整铺满整个数组，最大出现次数不会超过原数组长度，数组下标可以直接代表“出现次数”，数组存储值代表“有多少个数字拥有该出现次数”。
2. 遍历上一步得到的频次哈希映射 cnt 的每一个计数值（也就是各个数字的出现次数）：
- • 把当前计数值作为下标，对应 cc 数组位置的值 +1；含义是：拥有该出现次数的数字数量增加一个。
3. 示例遍历后 cc 数组关键位置结果：
- • 下标1（出现1次）：对应值为2，代表有2个数字（20、10）只出现1次；
- • 下标2（出现2次）：对应值为1，代表仅有1个数字（30）出现2次；其余下标数值均为0。

步骤3：再次从左到右遍历原数组，寻找第一个频率唯一的数字

1. 重新从头按顺序扫描原始输入数组，保证满足“第一个”的要求；
2. 对当前遍历到的数字，先去哈希映射 cnt 取出它的出现次数；
3. 用这个出现次数作为下标读取 cc 数组的值：
- • 若读取结果等于1，说明当前数字的出现次数是全局独一份，没有其他数字和它出现次数相同，符合题目要求；
- • 立刻直接返回当前数字，终止全部流程，不再继续遍历；
4. 示例逐元素校验过程：
- • 第一个数字20：出现次数1，cc[1]=2，不等于1，不满足；
- • 第二个数字10：出现次数1，cc[1]=2，不等于1，不满足；
- • 第三个数字30：出现次数2，cc[2]=1，等于1，满足条件，直接返回30；
5. 若完整遍历完整个数组，所有数字的出现次数都存在重复（所有cc[次数]>1），说明不存在频率唯一的元素，最终返回-1。

二、时间复杂度分析

1. 第一次遍历原数组统计频次：数组长度为n，时间复杂度；
2. 遍历哈希映射统计频次的频次：哈希映射中键的数量最多为n（所有数字互不重复），最坏时间复杂度；
3. 第二次遍历原数组查找目标元素：数组长度n，时间复杂度；三段操作依次串行执行，相加后总时间复杂度：。

三、额外空间复杂度分析

1. 哈希映射cnt：最坏情况所有数字不重复，存储n个键值对，占用；
2. 数组cc：长度固定为，占用；无其他随输入规模线性增长的临时存储，总额外空间复杂度：。

Go完整代码如下：

package main

import (
    "fmt"
)

func firstUniqueFreq(nums []int)int {
    cnt := map[int]int{}
    for _, x := range nums {
        cnt[x]++
    }

    cc := make([]int, len(nums)+1)
    for _, c := range cnt {
        cc[c]++
    }

    for _, x := range nums {
        if cc[cnt[x]] == 1 {
            return x
        }
    }
    return-1
}

func main() {
    nums := []int{20, 10, 30, 30}
    result := firstUniqueFreq(nums)
    fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

def first_unique_freq(nums):
    # Count frequency of each number
    cnt = {}
    for x in nums:
        cnt[x] = cnt.get(x, 0) + 1
    
    # Count how many numbers have each frequency
    cc = [0] * (len(nums) + 1)
    for c in cnt.values():
        cc[c] += 1
    
    # Find the first number whose frequency appears only once
    for x in nums:
        if cc[cnt[x]] == 1:
            return x
    return-1

def main():
    nums = [20, 10, 30, 30]
    result = first_unique_freq(nums)
    print(result)

if __name__ == "__main__":
    main()

C++完整代码如下：

#include <iostream>
#include <vector>
#include <unordered_map>

int firstUniqueFreq(std::vector<int>& nums) {
    std::unordered_map<int, int> cnt;
    for (int x : nums) {
        cnt[x]++;
    }

    std::vector<int> cc(nums.size() + 1, 0);
    for (const auto& pair : cnt) {
        cc[pair.second]++;
    }

    for (int x : nums) {
        if (cc[cnt[x]] == 1) {
            return x;
        }
    }
    return-1;
}

int main() {
    std::vector<int> nums = {20, 10, 30, 30};
    int result = firstUniqueFreq(nums);
    std::cout << result << std::endl;
    return0;
}