剑指offer 学习笔记 数组中数字出现的次数

面试题56：数组中数字出现的次数。
1.一个整型数组里除两个数字之外，其他数字都出现了两次，找出这两个只出现一次的数字，要求时间复杂度O（n），空间复杂度O（1）。

先分析如果只有一个数字出现一次，而其他数字都出现了两次，我们就可以依次异或数组中的每个数字，由于异或运算满足交换律，因此只要异或序列中有两个相同的数字就可以将这两个数字都变为0，而0与任何数字异或都是这个数字自己，这样最后的异或结果就是这个只出现一次的数。

而回到本题，如像上述分析一样依次异或，那最后的结果一定不是0，因为它相当于两个不相等的值异或，而这个非0的结果的二进制中必然有一位是1，将这个1所在位数记为n，这个1的由来就是这两个不同数的第n位不同，因此，我们只需要将整个数组以第n位为1或0来分割成两个子数组，这样那两个只出现一次的数就被分到了两个数组中，而数组中其他每一对值相同的元素也都被分到了相同的子数组中，这样就可以用刚分析的方法找出这两个数了：

#include <iostream>
using namespace std;

int FindIndexOf1(int num) {
    int index = 0;
    while (((index & 1) == 0) && (index < sizeof(int) * 8)) {
        num >>= 1;
        ++index;
    }
    return index;
}

bool IsBitkIs1(int num, int k) {
    num >>= k;
    return num & 1;
}

void FindNumAppearOnce(int* nums, int length, int& res1, int& res2) {
    if (nums == nullptr || length < 2) {
        return;
    }

    int resOfExclusiveOr = 0;
    for (int i = 0; i < length; ++i) {
        resOfExclusiveOr ^= nums[i];
    }

    int indexOf1 = FindIndexOf1(resOfExclusiveOr);

    res1 = res2 = 0;
    for (int i = 0; i < length; ++i) {
        if (IsBitkIs1(nums[i], indexOf1)) {
            res1 ^= nums[i];
        } else {
            res2 ^= nums[i];
        }
    }
}

int main() {
    int res1 = 0, res2 = 0;
    int nums[] = { 0,1,2,2,3,4,0,4 };
    FindNumAppearOnce(nums, sizeof(nums) / sizeof(*nums), res1, res2);
    cout << res1 << " " << res2 << endl;
}

2.在一个数组中除一个数字只出现一次外，其他数字都出现了三次，找出那个只出现一次的数字。

我们只需要计算出数组中每个数字的二进制位表示中每一位中1出现的个数，之后每一位中1的个数除以3，如余数为0（1），说明这个只出现一次的数字的该位为0（1），而余数只会为0或1：

#include <iostream>
using namespace std;

int FindNumAppearingOnce(int* nums, int length) {
    if (nums == nullptr || length <= 0) {
        throw exception("Invalid input.");
    }

    const int bitNumOfInt = sizeof(int) * 8;
    int bitSum[bitNumOfInt] = { 0 };    // 保存所有数字的每一位中1的数量

    for (int i = 0; i < length; ++i) {
        int bitMask = 1;
        for (int j = bitNumOfInt - 1; j >= 0; --j) {
            bitSum[j] += bitMask & nums[i];
            bitMask <<= 1;
        }
    }

    int res = 0;
    for (int i = 0; i < 32; ++i) {
        res <<= 1;    // 此处先左移再给最低位赋值，如先赋值，最后一次循环将使最高位溢出
        res += bitSum[i] % 3;
    }
    return res;
}

int main() {
    int nums[] = { 1,2,3,3,2,5,1,5,1,5,3 };
    cout << FindNumAppearingOnce(nums, sizeof(nums) / sizeof(*nums)) << endl;
}

这种解法时间复杂度为O（n），空间上我们需要一个大小为32的int数组，空间复杂度为O（1），这比其他两种直观方法的效率要高：
1.从排序的数组中找到只出现一次的数字，但排序的时间复杂度为O（nlogn）。
2.用哈希表记录数字出现的次数，空间复杂度为O（n）。