经典算法题1：找出数组中只出现一次的数字，其它数字都出现了两次

题目：一个整型数组里除了一个数字之外，其它的数字都出现了两次。请写程序找出这个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。

分析：由于题目要求时间复杂度为O(n)，所以先排序然后比较相邻数字是否相同的思路被排除。

            空间复杂度是O(1)，辅助空间被限制，所以hash表的思路也被排除。

           那么这个题的突破口在哪里呢？注意这个数组的特殊性：其它数字都出现了两次，只有一个数出现了一次。可以想到运用异或运算，任何一个数字异或它自己都等于0。

           如果我们从头到尾依次异或数组中的每一个数，那么最终的结果就是那个只出现一次的数字，因为其他出现两次的数字全部在异或中被抵消为0了（异或运算遵循交换分配率）。

           举个栗子：2  3  4  2  3

           所有数字依次异或运算：2 xor 3 xor 4 xor 2 xor 3 = (2 xor 2) xor (3 xor 3) xor 4= 0 xor 0 xor 4 = 4

          最终结果4就是我们要找的那个只出现一次的数字。

void FindNumsAppearOnce(int data[], int length, int &num1)  
{  
    if (length < 2)  
        return;  
    int resultExclusiveOR = 0;  
    for (int i = 0; i < length; ++ i)  
        resultExclusiveOR ^= data[i];  
        num1=resultExclusiveOR ;  
}  

此题的扩展：一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。

分析：数组里包含了两个只出现一次的数字，那么所有数字依次异或的结果就是这两个只出现一次的数字的异或结果。我们要想办法利用这个异或结果，把数组分为两个子数组，一个子数组包含一个只出现一次的数字，另一个数组包含另一个只出现一次的数字。由于这两个只出现一次的数字肯定不相等，那么这个异或结果肯定不为0，也就是说在这个结果数字的二进制表示中至少就有一位为1。我们在结果数字中找到第一个为1的位的位置，记为第N位。现在我们以第N位是不是1为标准把原数组中的数字分成两个子数组，第一个子数组中每个数字的第N位都为1，而第二个子数组的每个数字的第N位都为0。

           举个栗子：1 2 3 4 2 3

          所有数字异或结果 = 1 xor 4

           二进制表示为：  001

                                xor 100

                                _______

                                       101

         异或结果的二进制位101，第一个为1的位的位置N=1。

         那么，数组所有数的二进制表示中，第N(N=1)位为1的的数为1 3 3，第N(N=1)位为0的的数为2 2 4.

         这样就把原数组拆分为两个子数组，1和4被分到不同的数组中去了。然后分别在两个子数组中找只出现一次的那个数。

void FindNumsAppearOnce(int data[], int length, int &num1, int &num2)  
{  
    if (length < 2)  
        return;  
   
    // get num1 ^ num2  
    int resultExclusiveOR = 0;  
    for (int i = 0; i < length; ++ i)  
        resultExclusiveOR ^= data[i];  
   
    // get index of the first bit, which is 1 in resultExclusiveOR  
    unsigned int indexOf1 = FindFirstBitIs1(resultExclusiveOR);   
   
    num1 = num2 = 0;  
    for (int j = 0; j < length; ++ j)  
    {  
        // divide the numbers in data into two groups,  
        // the indexOf1 bit of numbers in the first group is 1,  
        // while in the second group is 0  
        if(IsBit1(data[j], indexOf1))  
            num1 ^= data[j];  
        else  
            num2 ^= data[j];  
    }  
}  
   
// Find the index of first bit which is 1 in num (assuming not 0)  
unsigned int FindFirstBitIs1(int num)  
{  
    int indexBit = 0;  
    while (((num & 1) == 0) && (indexBit < 32))  
    {  
        num = num >> 1;  
        ++ indexBit;  
    }  
   
    return indexBit;  
}  
   
  
// Is the indexBit bit of num 1?  
bool IsBit1(int num, unsigned int indexBit)  
{  
    num = num >> indexBit;  
   
    return (num & 1);  
}  

方法二：

直接遍历整个数组，建成类似hash的数组。用原始数组中元素值当hash数组下标，出现次数当hash数组元素值。最后再遍历一次hash，找出值为1元素的下标。或者不用hash数组，用map的键值对。思想一样的。

时间复杂度：O(n)

空间复杂度：O(n)

还有没有更优的算法呢？联想到我们用位操作找出数组中只出现一次的元素的思想，这里同样可以用位操作找出只出现一次的两个元素。