Letcode每日一题：137. 只出现一次的数字 II

题目

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

示例 1：
输入：nums = [2,2,3,2]
输出：3

示例 2：
输入：nums = [0,1,0,1,0,1,99]
输出：99
提示：

1 <= nums.length <= 3 * 104
-231 <= nums[i] <= 231 - 1
nums 中，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次

思路一：暴力解法

使用Set储存出现过的数，然后计算数组中的所有数字的总和，所以得到如下公式：

只出现一次的数 = （出现过的数字 * 2 - 数字总和）/ 2

开始使用int储存总和等值，但是letcode的数据很大很多，多以后来选择了BigInteger类来存储。

public class pro137_2 {
    public int singleNumber(int[] nums) {
        BigInteger three = new BigInteger("3");
        BigInteger two = new BigInteger("2");
        BigInteger all = new BigInteger("0");
        BigInteger sigleAll = new BigInteger("0");
        BigInteger temp ;
        Set<Integer> hashSet = new HashSet<>();
        for (int num : nums) {
            temp2 =BigInteger.valueOf((long) num);
            all=all.add(temp2);
            hashSet.add(num);
        }
        for (int n : hashSet) {
           temp2 = BigInteger.valueOf((long)n);
            sigleAll=sigleAll.add(temp2);
        }
        return sigleAll.multiply(three).subtract(all).divide(two).intValue();

    }
}

但是性能太低，所以换种思路。

思路二：普通排序法（不符合题目：时间复杂度）

排序后每三位相邻的数字判断一下是否相等，就可以很容易找出单独的哪一个。

class Solution {
    public int singleNumber(int[] nums) {
    	//对数组排序
         Arrays.sort(nums);
         //判断情况
        if (nums.length == 1 )return nums[0];
        if (nums[0] != nums[1])return nums[0];
        if (nums[nums.length-1] != nums[nums.length-2])return nums[nums.length-1];
        for (int i = 0; i < nums.length; i += 3) {
            if (nums[i] != nums[i+1])return nums[i];
        }
        return 0;
    
    }
}

思路四：位运算（一）

引用大佬思路：
【笔记】网上大佬曾经说，如果能设计一个状态转换电路，使得一个数出现3次时能自动抵消为0，最后剩下的就是只出现1次的数。

开始设计：一个二进制位只能表示0或者1。也就是天生可以记录一个数出现了一次还是两次。

x ^ 0 = x;
x ^ x = 0;

要记录出现3次，需要两个二进制位。那么上面单独的x就不行了。我们需要两个变量，每个变量取一位：

ab ^ 00 = ab;
ab ^ ab = 00;

这里，a、b都是32位的变量。我们使用a的第k位与b的第k位组合起来的两位二进制，表示当前位出现了几次。也就是，一个8位的二进制x就变成了16位来表示。

x = x[7] x[6] x[5] x[4] x[3] x[2] x[1] x[0]
x = (a[7]b[7]) (a[6]b[6]) … (a[1]b[1]) (a[0]b[0])

于是，就有了这一幕…
它是一个逻辑电路，a、b变量中，相同位置上，分别取出一位，负责完成00->01->10->00，也就是开头的那句话，当数字出现3次时置零。

int singleNumber(vector<int>& nums) {
    int a = 0, b = 0;
    for (auto x : nums) {
        b = (b ^ x) & ~a;
        a = (a ^ x) & ~b;
    }
    return b;
}

---

主要是位运算实现当一个数字出现三次时，标记变量能够变成0
对于某个变量有如下过程

1. 第一个数字

b = (b ^ x) & ~a = x;
a = (a ^ x) & ~b = 0;

2. 第二个数字

b = (b ^ x) & ~a = 0;
a = (a ^ x) & ~b = x;

3. 第三个数字

b = (b ^ x) & ~a = 0;
a = (a ^ x) & ~b = 0;

思路五：位运算（二）

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

把所有数字的二进制看成一个表格，对齐每个二级制相加对3求余就可以轻松得到只出现一次的数字了，然后把结果的二进制转换成int类型的数字就是结果了。

思路六：哈希表

class Solution {
    public int singleNumber(int[] nums) {
        HashMap<Integer,Integer> a = new HashMap<>();
        for(int num : nums){
            a.put(num,a.getOrDefault(num,0)+1);
        }
        for(int b :a.keySet()){
            if(a.get(b)==1){
                return b;
            }
        }
        return -1;
    }
}