Easy

题目描述

给你一个整数数组 nums。数组中唯一元素是在数组中只出现一次的元素。

请你返回 nums 中唯一元素的和。

示例 1：

输入：nums = [1,2,3,2]
输出：4
解释：唯一元素为 [1,3]，和为 4。

示例 2：

输入：nums = [1,1,1,1,1]
输出：0
解释：没有唯一元素，和为 0。

示例 3：

输入：nums = [1,2,3,4,5]
输出：15
解释：唯一元素为 [1,2,3,4,5]，和为 15。

提示：

  • 1 <= nums.length <= 100
  • 1 <= nums[i] <= 100

解题思路

这道题要求计算数组中只出现一次的元素的和。解决思路很简单：统计每个元素的出现次数，然后对出现次数为1的元素求和。

方法一：哈希表计数（推荐） 使用哈希表统计每个元素的出现次数，然后遍历哈希表，将出现次数为1的元素累加到结果中。这是最直观的解法。

方法二：一次遍历优化 由于数组长度和元素值范围都很小，可以使用一次遍历的优化方法。在遍历过程中，如果某个元素第一次出现就加到结果中，如果第二次出现就从结果中减去。这样能减少遍历次数，但代码稍复杂。

考虑到题目的数据规模较小，推荐使用哈希表计数的方法，代码简洁易懂，性能也完全够用。

代码实现

class Solution {
public:
    int sumOfUnique(vector<int>& nums) {
        unordered_map<int, int> count;
        for (int num : nums) {
            count[num]++;
        }
        
        int sum = 0;
        for (auto& pair : count) {
            if (pair.second == 1) {
                sum += pair.first;
            }
        }
        
        return sum;
    }
};

class Solution:
    def sumOfUnique(self, nums: List[int]) -> int:
        count = {}
        for num in nums:
            count[num] = count.get(num, 0) + 1
        
        return sum(num for num, freq in count.items() if freq == 1)

public class Solution {
    public int SumOfUnique(int[] nums) {
        Dictionary<int, int> count = new Dictionary<int, int>();
        foreach (int num in nums) {
            if (count.ContainsKey(num)) {
                count[num]++;
            } else {
                count[num] = 1;
            }
        }
        
        int sum = 0;
        foreach (var pair in count) {
            if (pair.Value == 1) {
                sum += pair.Key;
            }
        }
        
        return sum;
    }
}

var sumOfUnique = function(nums) {
    const count = {};
    
    for (const num of nums) {
        count[num] = (count[num] || 0) + 1;
    }
    
    let sum = 0;
    for (const num in count) {
        if (count[num] === 1) {
            sum += parseInt(num);
        }
    }
    
    return sum;
};
在 LeetCode 上运行： 力扣中文版 LeetCode 国际版

复杂度分析

复杂度哈希表计数方法
时间复杂度O(n)
空间复杂度O(n)

其中 n 是数组 nums 的长度。时间复杂度为 O(n) 是因为需要遍历数组一次统计频次，再遍历哈希表一次计算结果。空间复杂度为 O(n) 是因为最坏情况下所有元素都不相同，哈希表需要存储 n 个元素。