落单的数（落单的数 & 落单的数 II & 落单的数 III）

落单的数

给出2*n + 1 个的数字，除其中一个数字之外其他每个数字均出现两次，找到这个数字。

样例
给出 [1,2,2,1,3,4,3]，返回 4

挑战 
一次遍历，常数级的额外空间复杂度

思路1：利用异或的性质（自反性）

自反性：a ^ b ^ a = b.
异或运算最常见于多项式除法，不过它最重要的性质还是自反性：
A^B^ B=A，即对给定的数A，用同样的运算因子（B）作两次异或运算后仍得到A本身。这是一个神奇
的性质，利用这个性质，可以获得许多有趣的应用。例如，所有的程序教科书都会向初学者指出，要交换两个变量的值，必须要引入一个中间变量。但如果使用异或，就可以节约一个变量的存储空间：
设有A,B两个变量，存储的值分别为a，b，则以下三行表达式将互换他们的值 表达式（值）：
A=A^B(a^b)
B=B^A(b^a^b=a)
A=A^B(a^b^a=b)

这道题利用了异或位运算的一个性质，即：一个数与自身异或的结果为0。我们只需遍历数组中的每一个元素，并将其进行异或。因为，异或满足交换律，所以最终的异或结果将仅仅包含只出现一次的那个数。
如：1 ^ 2 ^ 2 ^ 1 ^3 ^ 4 ^ 3 = 1 ^ 1 ^ 2 ^ 2 ^ 3 ^ 3 ^ 4 = 4

代码如下：

class Solution {
public:
    /*
     * @param A: An integer array
     * @return: An integer
     */
    int singleNumber(vector A) {
        // write your code here
        //采用异或的操作可以解决这个问题
        if(A.empty())return 0;
        int n = A[0];
        for(int i = 1;i != A.size();++i){
            n = n^A[i];
        }
        return n;
    }
};

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

思路二：

若一个数字出现2次，则该数字的二进制表示中每个位置的数值为1的出现次数为2次，如：5的二进制表示为101，若5出现3次，则其二进制表示中的第一个位置和第二个位置出现1的次数和均为2。那么对该位1出现的次数对2取余，最终的结果所对应的就是所要求的Sing Number。

代码：

class Solution {
public:
    /*
     * @param A: An integer array
     * @return: An integer
     */
    bool isBit1(int num, int index)  {
        num = num >> index;
        return (num & 1);
    }

    int singleNumber(vector &A) {
        int n = A.size();
        int result = 0;
        for(int i = 0; i < 32; ++i) {
            int count = 0;
            for(int j = 0; j < n; ++j) {
                if(isBit1(A[j], i))
                    ++count;
            }
            result |= (count % 2) << i;
        }
        return result;
    }
};

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

落单的数 II

给出3*n + 1 个的数字，除其中一个数字之外其他每个数字均出现三次，找到这个数字。
样例
给出 [1,1,2,3,3,3,2,2,4,1] ，返回 4
挑战 
一次遍历，常数级的额外空间复杂度

思路：

与Single Number I 类似，所不同的是这道题除了一个数字之外都出现3次，仍然考虑使用位操作，尝试消除掉出现3次的数字。
若一个数字出现3次，则该数字的二进制表示中每个位置的数值为1的出现次数为3次，如：5的二进制表示为101，若5出现3次，则其二进制表示中的第一个位置和第二个位置出现1的次数和均为3。那么对该位1出现的次数对3取余，最终的结果所对应的就是所要求的Sing Number。
解题方法：与Single Number I 类似，所不同的是这道题除了一个数字之外都出现3次，仍然考虑使用位操作，尝试消除掉出现3次的数字。
若一个数字出现3次，则该数字的二进制表示中每个位置的数值为1的出现次数为3次，如：5的二进制表示为101，若5出现3次，则其二进制表示中的第一个位置和第二个位置出现1的次数和均为3。那么对该位1出现的次数对3取余，最终的结果所对应的就是所要求的Sing Number。
代码如下：

class Solution {
public:
	/**
	 * @param A : An integer array
	 * @return : An integer 
	 */
    bool isBit1(int num, int index)  {
        num = num >> index;
        return (num & 1);
    }

    int singleNumberII(vector &A) {
        int n = A.size();
        int result = 0;
        for(int i = 0; i < 32; ++i) {
            int count = 0;
            for(int j = 0; j < n; ++j) {
                if(isBit1(A[j], i))
                    ++count;
            }
            result |= (count % 3) << i;
        }
        return result;
    }
};

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

落单的数 III

给出2*n + 2个的数字，除其中两个数字之外其他每个数字均出现两次，找到这两个数字。
样例
给出 [1,2,2,3,4,4,5,3]，返回 1和5
挑战 
O(n)时间复杂度，O(1)的额外空间复杂度

思路：

与以上两题不同的是，这道题有两个数只出现一次。基本的思路还是利用位运算，除去出现次数为2次的数。

如果对所有元素进行异或操作，最后剩余的结果是出现次数为1次的两个数的异或结果，此时无法直接得到这两个数具体的值。但是，因为这两个数一定是不同的，所以最终异或的值至少有一个位为1。我们可以找出异或结果中第一个值为1的位，然后根据该位的值是否为1，将数组中的每一个数，分成两个部分。这样每个部分，就可以采用Sing number I中的方法得到只出现一次的数。

代码：

class Solution {
public:
    /*
     * @param A: An integer array
     * @return: An integer array
     */
    int findindex(int number){
        int index = 0;
        while((number&1) == 0){
            ++ index;
            number >>= 1;
        }
        return index;
    }
        
    bool isBit1(int num, int index){
        num = num >> index;
        return (num & 1);
    }
    
    vector singleNumberIII(vector A) {
        // write your code here
        // if(A.empty())return vector();
        vector result;
        int twonumbers = 0;
        for(int i =0;i!=A.size();++i){
            twonumbers ^= A[i];
        }
        int index = findindex(twonumbers);
        int num1 = 0,num2 = 0;
        for(int i = 0;i!=A.size();++i){
            if(isBit1(A[i],index)){
                num1 ^= A[i];
            }
            else{
                num2 ^= A[i];
            }
        }
        result.push_back(num1);
        result.push_back(num2);
        return result;
    }
};

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