LeetCode——136. Single Number＆＆137. Single Number II

——Single Number
问题描述：

Given an array of integers, every element appears twice except for one. Find that single one.

Note:
Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

　　题目大致的意思就是给你一个整型的数组，其中的每个元素都会出现两次，除了一个元素，它只出现一次，要你找出这个元素。
　　如果不对空间复杂度做要求的话，线性时间复杂度的解决办法还是挺容易想到的：用一个hashmap来保存元素。如果该元素第一次出现，直接将他作为键插入进去；如果该元素第二次出现，即在hashmap中能够找到这个元素，就在hashmap中删除这个键。最后hashmap中剩下的键就是只出现一次的元素。代码如下：

    public int singleNumber(int[] nums) {
        //常规解法，需要线性的空间复杂度
        Map<Integer, Integer> tempMap = new HashMap<>();
        for(int i : nums) {
            if(tempMap.containsKey(i))
                tempMap.remove(i);
            else {
                tempMap.put(i, 1);
            }
        }
        int result = 0;
        for(int a : tempMap.keySet()) {
            result = a;
        }
        return result;
    }

　　当然，题目有更进一步的要求，要求空间复杂度为常数级。常数级空间复杂度，就有点麻烦。而且还要求线性的时间复杂度。所以只能在数组上进行操作，而且操作的话，要线性复杂度，所以估计也就是每遍历一个元素，进行一步操作而已。所以就会想到各种运算。加减乘除肯定行不通，位操作，就想到了异或。因为异或两个相同的数，结果为0,0与任何数异或为它本身。此外，异或这个运算符满足交换律，就是异或的顺序是可以相互交换的，不就正好符合我们题目的条件吗。所有出现了两次的元素运算后变为０，再与唯一出现一次的元素异或，就是它本身，问题就解决了。以下是代码：

    public int singleNumber(int[] nums) {
        //常数级空间复杂度
        int result = 0;
        for(int i = 0; i < nums.length; i++) {
            result ^= nums[i];
        }
        return result;
    }

　　以上就是第一题的解法啦，有一点难度，但总的来说，还是可以想得到的。

接下来是第二题——Single Number II
问题描述：

Given an array of integers, every element appears three times except for one, which appears exactly once. Find that single one.

Note:
Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

　　这道题大致的意思与上面那题相同，只不过出现两次的元素换成了出现三次。
　　如果不对空间复杂度做要求的话，解法还是很简单，依然是用hashmap，当某元素出现了三次，就在hashmap中删除这个键，最后剩余的那个键就是结果，这里就不贴代码了。
　　真正有挑战的是空间复杂度为常数级的要求。按照上一题的思路，这里的解法肯定还是遍历每一个元素的同时做一些简单的运算，遍历完后直接返回结果，这样才能满足题目的要求。那么需要使用什么样的运算呢？刚开始我也是想不明白，后来看到了大神们的博客，才真正理解了其中的奥秘。
　　既然直接整一个数来进行运算行不通，那我们可以换个想法，将整数看成是二进制数，来进行分析。
　　试想一下，因为位操作本身都是可以自由交换、结合的，如果一个整数出现三次，那么在它的二进制数上，相同的位上三次出现的数都相同。那么我们可以断定，如果某个位上１同时出现了三次，这个位就需要置为０。这里不太好说，大家可以看我的注释。代码如下：

    public int singleNumber(int[] nums) {
        //ones用来记录出现了一次的位
        int ones = 0;
        //twos用来记录出现了两次的位
        int twos = 0;
        //threes用来记录出现了三次的位
        int threes = 0;
        //一个数出现了三次，则它的位组合肯定也出现了三次
        //想法就是因为我们只需要出现了一次的位，出现了三次的位我们要去掉（就代表了所有出现了３次的数）
        //所以我们用三个数来保存出现了相应次数的位
        //然后每遍历到一个数，就对三个参数进行调整
        //最后ones剩下的位，就是只出现了一次的位，组合起来就是我们想要的数
        for(int i = 0; i < nums.length; i++) {
            int t = nums[i];
            //根据ones调整twos中的位
            twos = twos | (ones & t);
            //调整ones中的位
            ones = ones ^ t;
            //调整threes中的位
            threes = twos & ones;
            //最后再根据threes中的结果，即出现了三次的位要进行删除，来修正ones和twos
            ones = ones & (~threes);
            twos = twos & (~threes);
        }
        return ones;
    }

　　对于这两道题，我觉得核心的想法还是在于对数的位操作上，因为很明显，这里无法对整个数进行运算操作了，那么我们就要想到对数进行细分再来操作，对数进行细分，那就只能是把它转换成二进制数来思考。如果你能够想到这一步，再想到位运算操作中的一些特性，比如异或本身结果为０，异或０结果为本身等，那么这两道题就可以迎刃而解了。
　　谢谢大家观看我的博客。如果有不明白的地方，或者是文中有错误的地方，欢迎指出，谢谢！如果大家喜欢我的博客，也可以给我点点赞。你们的点赞就是我的动力！