位运算算法题

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

    public int singleNumber(int[] nums) {
        Map<Integer, Integer> map = new HashMap<>();
        //存储元素出现的次数
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
        }
        //遍历获取出现次数为1的情况
        for (int k : map.keySet()) {
            if (map.get(k) == 1) {
                return k;
            }
        }
        return -1;
    }

时间复杂度：O(n)
空间复杂度：O(n)

1. 一个数和其本身做 异或 运算等于 0：a^a = 0
2. 一个数和其本身做 异或 运算等于 0：a^a = 0
3. 异或 运算满足交换律和结合律：a^b ^a = (a ^a) ^b = 0 ^b = b

    public int singleNumber(int[] nums) {
        int ans = 0;
        for (int i = 0; i < nums.length; i++) {
            //异或运算
            ans ^= nums[i];
        }
        return ans;
    }

时间复杂度：O(n)
空间复杂度：O(1)

• 给你一个整数数组nums, 除某个元素仅出现 一次 外，其余每个元素都恰出现 **三次 。**请你找出并返回那个只出现了一次的元素。

哈希法

    public int singleNumber(int[] nums) {
        if (nums.length == 1) {
            return nums[0];
        }
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
        }
        for (int k : map.keySet()) {
            if (map.get(k) == 1) {
                return k;
            }
        }
        return -1;
    }

时间复杂度：O(n)
空间复杂度：O(n)

如果其他数都出现 3 次，只有目标数出现 1 次，那么每一位的 1 的个数无非有这两种情况，

1. 为 3 的倍数（全为出现三次的数）
2. 3 的倍数 +1（包含出现一次的数） (目标数)

    public int singleNumber(int[] nums) {
        int res = 0;
        for (int i = 0; i < 32; i++) {
            int count = 0;
            for (int num : nums) {
                //检查第i位是否为1
                if ((num >> i & 1) == 1) {
                    count++;
                }
            }
            if (count % 3 != 0) {
                //将第i位设为1
                res = res | 1 << i;
            }
        }
        return res;
    }

时间复杂度：O(n)
空间复杂度：O(1)

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

哈希法

    public int[] singleNumber(int[] nums) {
        int[] res = new int[2];
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
        }
        int index = 0;
        for (int k : map.keySet()) {
            if (map.get(k) == 1) {
                res[index] = k;
                index++;
            }
        }
        return res;
    }

时间复杂度：O(n)
空间复杂度：O(n)

异或运算对应位相同，结果是0，否则结果是1, 把它分成两组.
根据两个数某一位是否是0和1来把数组分为两组。

例如数组： [12，13，14，17，14，12]
3、17的异或值，可以仅保留异或值的分组位，其余位变为 0，例如 11100变成00100。 利用 x & (-x) 来保留最右边的 1。

    public int[] singleNumber(int[] nums) {
        int bitMask = 0;
        //把数组中的所有元素全部异或一遍
        for (int num : nums) {
            bitMask ^= num;
        }
        //保留最右边的1
        bitMask &= -bitMask;
        int[] res = {0, 0};
        for (int num : nums) {
            //将数组分成两部分，每部分分别异或
            if ((num & bitMask) == 0) {
                res[0] ^= num;
            } else {
                res[1] ^= num;
            }
        }
        return res;
    }

参考1
参考2
参考3
参考4
参考5
参考6