只出现一次的数列

I

给定一个非空整数数组，除了某个元素只出现一次之外，其余每个元素均出现两次。找出那个只出现了一次的元素。

输入: [4,1,2,1,2]
输出: 4

思路一：位运算

1. ret初始值为0，作为连续异或操作的初始值
2. 注意将所有整数，转化成二进制形式考虑

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ret = 0;
        for (auto e: nums) ret ^= e;
        return ret;
    }
};

时间复杂度：

• 时间复杂度：O(N) 异或操作O(1)，遍历一遍数组
• 空间复杂度：O(1) 没有用到额外的空间

II

给定一个整数数组nums，除某个元素仅出现一次外，其余每个元素都恰出现三次。找出只出现了一次的元素。

输入：nums = [0,1,0,1,0,1,99]
输出：99

思路：哈希表

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        unordered_map<int, int> freq;
        for (int num: nums) {
            ++freq[num];
        }
        int ans = 0;
        for (auto [num, occ]: freq) {
            if (occ == 1) {
                ans = num;
                break;
            }
        }
        return ans;
    }
};

思路二： 位运算

位运算的思路是比较巧妙的：
bits数组含义：bits[32]，长度为32，表示数字在二进制表示下第i位为1的个数

首先： 用一个数组bits[32]记录在二进制的32位中，每一个数字在这32位中出现1的次数
举个例子：
数字7的二进制表示为… 0000 0111，则将bits[0], bits[1], bits[2]都加一

其次： 显而易见，若一个数字出现3次，则这些位数都会加3
承接上例：
数字7出现3次，则得到bits数组如右 … 0000 0333

最后： 因此我们很自然的想到，若对于数组每一位进行 mod 3 运算，就可以抵消这些出现3次数字所带来的变动
承接上例：
bits[32]数组 mod 3 后变为 … 0000 0000

因此通过上述的3个步骤，我们就能得到出现1次的数字的2进制表示，最后再转化一下就可以得到答案了

最后用一个完整的例子带大家感觉一下
输入：[1,1,1, 2,2,2, 3, 5,5,5]
输出：3

输入数字的二进制表示：
1：… 0001
2：… 0010
3：… 0011
5：… 0101

因此bits数组为：bits[0] = 7, bits[1] = 4, bits[2] = 3
mod 3 运算后为：bits[0] = 1, bits[1] = 1, bits[2] = 0
动作 bits数组
插入3个1 (0001) 0 0 0 3
插入3个2 (0010) 0 0 3 3
插入1个3 (0011) 0 0 4 4
插入3个5 (0101) 0 3 4 7
mod 3 运算 0 0 1 1 = 3

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        vector<int> bits(32, 0);
        for(auto num : nums) {
            for(int i = 0; i < 32; i++) {
                if(num & (1 << i))
                    bits[i]++;
            }
        }
        int ans = 0;
        for(int i = 0; i < 32; i++) {
            bits[i] %= 3;
            if(bits[i] & 1)
                ans += (1 << i);
        }
        return ans;
    }
};

复杂度分析：

时间复杂度：O(32*n) = O(n)O(32∗n)=O(n)
空间复杂度：O(32) = O(1)O(32)=O(1)

III

给定一个整数数组nums。其中恰好有两个元素只出现一次，其余所有元素均出现两次。找出只出现一次的那两个元素。可以按任意顺序返回答案。

输入：nums = [1,2,1,3,2,5]
输出：[3,5]
解释：[5, 3] 也是有效的答案。

思路一：哈希表

不符合题目空间复杂度O(1)的进阶要求。

1. 用哈希表记录每个数出现的次数
2. 遍历哈希表，将次数为1的加入结果中。
3. 哈希表一波带走所有题目，哈哈哈

class Solution {
public:
    vector<int> singleNumber(vector<int>& nums) {
		unordered_map<int, int> freq;
		for (auto num : nums)
		{
			++freq[num];
		}
		vector<int> ans;
		int idx = 0;
		for (auto [num, occ]: freq) {
            if (occ == 1) {
                ans.push_back(num);
            }
        }
        return ans;
    }
};

思路二：分组位运算

1. 先对所有数字进行一次异或，得到两个出现一次的数字的异或值。
   比如[1,2,1,3,2,5]，得到了 0110，也就是6。
2. 在异或结果中找到任意为1的位。
3. 根据这一位对所有的数字进行分组
4. 在每个组内进行异或操作，得到两个数字

class Solution {
public:
    vector<int> singleNumber(vector<int>& nums) {
        int ret = 0;
        for (int n : nums)
            ret ^= n;
        int div = 1;
        while ((div & ret) == 0)
            div <<= 1;
        int a = 0, b = 0;
        for (int n : nums)
            if (div & n)
                a ^= n;
            else
                b ^= n;
        return vector<int>{a, b};
    }
};

复杂度分析：

• 时间复杂度：O(n)O(n)，我们只需要遍历数组两次。

• 空间复杂度：O(1)O(1)，只需要常数的空间存放若干变量。