力扣的位运算之“只出现一次数字”小结：

推荐一个总结位运算的网址：http://graphics.stanford.edu/~seander/bithacks.html#OperationCounting
分别为力扣上136、137、260、645题

1、只出现一次的数字

题目描述：

题解：
方法1：异或
记住一些结论：

https://leetcode-cn.com/problems/shu-zu-zhong-shu-zi-chu-xian-de-ci-shu-lcof/solution/zhi-chu-xian-yi-ci-de-shu-xi-lie-wei-yun-suan-by-a/

逐个元素进行异或，把所有有两个相同值的元素去掉，剩下一个数就是该数

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        if len(nums) < 1:
            return 0
        if len(nums)== 1:
            return nums[0]
        ans = nums[0]
        for i in range(1,len(nums)):
            ans ^= nums[i]
        return ans

方法2：列表操作，遍历，如果不在列表中就添加，在列表中删除，最后剩余的数字一定是没有重复 的那个数字。

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        res = []
        for num in nums:
            if i not in res:
                res.append(num)
            else:
                res.remove(num)
        return res.pop()

方法3：哈希表法。把原数组中的元素放到哈希表种，并统计出现的次数；遍历，如果次数为1，则返回那个key值

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        hash_table = collections.defaultdict(int)
        for i in nums:
            hash_table[i] += 1
        for num in nums:
            if hash_table[num] == 1:
                return num

4、数学法

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        return 2 * sum(set(nums)) - sum(nums)

复杂度：
方法1：
时间复杂度：O(N)
空间复杂度：O(1)
方法2：
时间复杂度：O(N^2)
空间复杂度：O(N)
方法3：
时间复杂度：O(N)
空间复杂度：O(N)
方法4：
时间复杂度：O(N)
空间复杂度：O(N)

2、只出现一次的数字 II

题目描述：

方法1：位运算

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        ones, twos = 0, 0
        for num in nums:
            ones = ones ^ num & ~twos
            twos = twos ^ num & ~ones
        return ones

方法二：hashset

class Solution:
    def singleNumber(self, nums):
        return (3 * sum(set(nums)) - sum(nums)) // 2

方法3：hashmap

from collections import Counter
class Solution:
    def singleNumber(self, nums):
        hashmap = Counter(nums)

        for k in hashmap.keys():
            if hashmap[k] == 1:
                return k

复杂度分析：
方法一：
时间复杂度：O(N)
空间复杂度：O(1)
最后两种：
时间和空间复杂度都是O(N)

3、只出现一次的数字 III

题目描述：

题解：
方法1：位运算

class Solution:
    def singleNumber(self, nums: List[int]) -> List[int]:
        res = 0 #所以数字异或的结果
        a = 0
        b = 0
        for num in nums:
            res ^= num
        #找到第一位不是0的值
        h = 1
        while res & h == 0:
            h <<= 1
        #分组
        for num in nums:
            if h & num == 0:
                a ^= num
            else:
                b ^=num
        return [a,b]

方法2：哈希表

from collections import Counter
class Solution:
    def singleNumber(self, nums: int) -> List[int]:
        hashmap = Counter(nums)
        return [x for x in hashmap if hashmap[x] == 1]

复杂度分析
方法1：
时间复杂度：O(N)
空间复杂度：O(1)
方法2：
时间复杂度：O(N)
空间复杂度：O(N)
4、错误的集合：
题目描述：

将数组的索引值1-n加入到数组中，转化为上题找不重复的两个数。之后遍历得知哪个是重复的，哪个是丢失的。

class Solution:
    def singleNumbers(self, nums: List[int]) -> List[int]:
        ret = 0  # 所有数字异或的结果
        a = 0
        b = 0
        for n in nums:
            ret ^= n
        # 找到第一位不是0的
        h = 1
        while(ret & h == 0):
            h <<= 1
        for n in nums:
            # 根据该位是否为0将其分为两组
            if (h & n == 0):
                a ^= n
            else:
                b ^= n

        return [a, b]

    def findErrorNums(self, nums: List[int]) -> List[int]:
        nums = [0] + nums#[0-n] 或者不从0开始也可以，下面的范围要做改动
        idx = []
        for i in range(len(nums)):#[0-n],此处的nums并不是原来的nums; 如果nums不从0开始，那么要改为range(1,len(nums)+1)
            idx.append(i)
        a, b = self.singleNumbers(nums + idx)
        for num in nums:
            if a == num:
                return [a, b]
        return [b, a]

复杂度分析：
时间复杂度：O(N)
空间复杂度：O(1)