一个数组里除两个数字外，其他数组都出现了两次，找出这两个只出现一次的数字

首先来看看 异或^ 我们知道：

1. 相同的两个数异或为0，不同的两个数异或为1
2. 0和任何数异或都为原本的数

例如：（int 是32bit，省略的用8bit）

/*
3 ^ 5
0000 0011 - 3
0000 0101 - 5
0000 0110 - ^
*/

根据异或的特性我们可以这样思考:

        既然数组里除了两个数组出现单次外，其他数字都出现了双次。那么我们它数组里面所有的数字都异或，得出的就是这两个单次数的异或。例如：

/*
1 ^ 2 ^ 3 ^ 5 ^ 1 ^ 2

0000 0001 - 1
0000 0010 - 2
0000 0011 - ^ - 3
0000 0011 - 3
0000 0000 - ^ - 0
0000 0101 - 5
0000 0101 - ^ - 5
0000 0001 - 1
0000 0100 - ^ - 4
0000 0010 - 2
0000 0110 - ^ - (3^5)
*/

接下来我们只要想办法分离这两个单数的异或就好了。   

---

        我们知道在计算机使用的是二进制（0 和 1），还知道两个数异或：相同为0 、不同为1

那么我们是不是可以这样想：

1. 数组里面除了两个数字出现一次外，其他数都出现了两次
2. 数组里面的数全部用二进制排列表示的话，除了两个单数的二进制，其他任何一位（32位）上都至少有2个1或者2个0（可以看下图）
3. 数组里面两个单数是不同的，用32bit表示，必定会有一位异或为1（否则就异或为0，就不会有两个单数了）
   1. 也就是说这两个单数在某一位上，一个为0，一个为1
4. 结合上面的除了两个单数的二进制，剩下的数在任何一位上都至少有2个1或2个0 ，和 这两个单数在某一位上一个为1，一个为0
5. 那我们可以在两个单数异或为1的那一位上给数组分类（假设为x位）
6. 在x位为1的数分在 A 数组，在x位为0的数分在 B 数组
   1. 应为之前说了除了两个单数，其余数在任何为都有2个0或2个1；所以其余数（不包含单数）分给A组在x位上为1的至少是2个；同样分给B组在x位上为0的也至少是2个。
   2. 之前也说了这两个单数在x位上一个为1，一个为0；那么分给A组的1为一个单数，分给B组的0也为一个单数。
7. 这样的话就把两个单数分别分到A组和B组去了。A组其余的数的二进制在x位上为1的至少有2个，B组其余数二进制在x位上位0的至少有2个
8. 把A组全部异或得到的就是A组中的单数；把B组全部异或得到的就是B组中的单数

/*
1 ^ 2 ^ 3 ^ 5 ^ 1 ^ 2

0000 0001 - 1
0000 0010 - 2
0000 0011 - 3
0000 0101 - 5
0000 0001 - 1
0000 0010 - 2
0000 0110 - ^ - (3^5)

除了3和5，其余数在任何一位上都有双数个1和双数个0
*/

---

代码：

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

int main()
{
	int arr[] = { 1, 2, 3, 5, 1, 2 };
	int sz = sizeof(arr) / sizeof(arr[0]);	//求出数组的个数
	int i = 0;
	int xor_result = 0;	//异或结果
	int count = 0;	//3^5的二进制右偏移几位为1（x）
	int* A = NULL;	//指向A数组的指针
	int* B = NULL;	//只想B数组的指针
	int j = 0;	//A数组下标
	int k = 0;	//B数组下标
	int xor_result_A = 0;	//A组异或
	int xor_result_B = 0;	//B组异或

	for (i = 0; i < sz; i++)	//求出数组中的异或结果(也就是 3 ^ 5)
	{
		xor_result ^= arr[i];
	}	

	if (xor_result == 0)	//判断数组中存在单数
	{
		printf("数组中没有单数\n");
	}
	
	while (1) // 3^5的二进制右偏移count位上1
	{
		if (((xor_result >> count) & 1) == 1)
		{
			break;
		}
		else
		{
			count++;
		}
	}

	A = (int*)malloc((sz / 2 + 1) * sizeof(int));	//创建A数组
	if (A == NULL)
	{
		printf("A:%s\n", strerror(errno));
		return 0;
	}

	B = (int*)malloc((sz / 2 + 1) * sizeof(int));	//创建B数组
	if (B == NULL)
	{
		printf("B:%s\n", strerror(errno));
		return 0;
	}

	for (i = 0; i < sz; i++)	//给数组分组
	{
		if (((arr[i] >> count) & 1) == 1)	//分给A组
		{
			A[j] = arr[i];
			j++;
		}
		else//分给B组
		{
			B[k] = arr[i];
			k++;
		}
	}

	for (i = 0; i < j; i++)	//A组异或
	{
		xor_result_A ^= A[i];
	}

	for (i = 0; i < k; i++)	//B组异或
	{
		xor_result_B ^= B[i];
	}

	printf("两个单数是：%d 和 %d\n", xor_result_A, xor_result_B);	//3 和 5

	return 0;
}

---

当然，写到了这里你会发现其实代码可以简略一点，比如：可以不用创建两个数组，分组之后直接异或就可以了。

代码：

#include <stdio.h>

int main()
{
	int arr[] = { 1, 2, 3, 5, 1, 2 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int xor_result = 0;	//异或结果
	int count = 0;	//3^5在第count位为1（从0开始）
	int xor_result_A = 0;	//A组异或
	int xor_result_B = 0;	//B组异或
	int i = 0;

	for (i = 0; i < sz; i++){	//数组全部异或（3^5)
		xor_result ^= arr[i];
	}

	while (1){	//3^5在第count位为1（从0开始）
		if (((xor_result >> count) & 1) == 1){
			break;
		}
		else{
			count++;
		}
	}

	for (i = 0; i < sz; i++){	//分组
		if (((arr[i] >> count) & 1) == 1){
			xor_result_A ^= arr[i];	//A组异或
		}
		else{
			xor_result_B ^= arr[i];	//B组异或
		}
	}

	printf("两个单数是：%d 和 %d\n", xor_result_A, xor_result_B);	//3 和 5

	return 0;
}