异或运算及其应用

异或是一种基于二进制的位运算，用符号XOR或者 ^ 表示，

其运算法则是对运算符两侧数的每一个二进制位，同值取0，异值取1。

它与布尔运算的区别在于，当运算符两侧均为1时，布尔运算的结果为1，异或运算的结果为0。

一、异或的性质

1. 交换律：a ^ b = b ^ a
2. 结合律：a ^ b ^ c = a ^ (b ^ c) = (a ^ b) ^ c
3. d = a ^ b ^ c 可以推出 a = d ^ b ^ c
4. 自反性：a ^ b ^ a = b

 

二、异或的应用

交换两个数

最常见的做法就是增加一个临时变量，代码如下：

 

    public void switchValue(int a, int b) {
        System.out.println("Before switch:    a:" + a + "\tb:" + b);
        int temp = b;
        b = a;
        a = temp;
        System.out.println("After switch:    a:" + a + "\tb:" + b);
    }

 

升级版，将两个数加减来实现，代码如下：

    public void switchValue(int a, int b) {
        System.out.println("Before switch:    a:" + a + "\tb:" + b);
        a = a + b;
        b = a - b;
        a = a - b;
        System.out.println("After switch:    a:" + a + "\tb:" + b);
    }

利用异或运算，也可以将两个数交换，例如：

public void switchValue(int a, int b) {
        System.out.println("Before switch:    a:" + a + "\tb:" + b);
        a = a^b;
        b = a^b;
        a = a^b;
        System.out.println("After switch:    a:" + a + "\tb:" + b);
}

 

 算法题目

 ①1-1000放在含有1001个元素的数组中，只有唯一的一个元素值重复，其它均只出现一次。每个数组元素只能访问一次，设计一个算法，将它找出来；不用辅助存储空间，能否设计一个算法实现？

解法一：将所有数加起来，减去1+2+...+1000的和。

这个算法已经足够完美了，相信出题者的标准答案也就是这个算法，唯一的问题是，如果数列过大，则可能会导致溢出。
解法二：异或就没有这个问题，并且性能更好。将所有的数全部异或，得到的结果与1^2^3^...^1000的结果进行异或，得到的结果就是重复数。

解法一很显然，解法二需要证明一下：

前面提到异或具有交换律和结合律，所以1^2^...^n^...^n^...^1000，无论这两个n出现在什么位置，都可以转换成为1^2^...^1000^(n^n)的形式。
其次，对于任何数x，都有x^x=0，x^0=x。
所以1^2^...^n^...^n^...^1000 = 1^2^...^1000^(n^n)= 1^2^...^1000^0 = 1^2^...^1000（即序列中除了n的所有数的异或）。

令，1^2^...^n^..^1000（序列中包含一个n）的结果为T 
则1^2^..^n^..^n^..^1000（序列中包含2个n）的结果就是T^n。 
T^(T^n)=n。
所以，将所有的数全部异或，得到的结果与1^2^3^...^1000的结果进行异或，得到的结果就是重复数。

 

②一个数组存放若干整数，一个数出现奇数次，其余数均出现偶数次，找出这个出现奇数次的数？

这个其实是①的一个变形题目，最直接的办法还是和上面一样，就是把所有数异或 (奇数个异或是本身，偶数个是0)

找出2n+1个数中不成对的那个(升级版)

谈到了用异或来解决，确实是个好方法，时间复杂度为o(n),比例一遍ok，空间复杂度为o(1),只占用一个空间足矣。现在把这个问题升级下：

（1）给出n个数，其中有且仅有一个出现了奇数次，其余的都出现了偶数次。用线性时间常数空间找出这个出现奇数次的数

（2）给定n个数，其中有且仅有两个出现了奇数次，其余的都出现了偶数次。用线性时间常数空间找出这两个出现奇数次的数

原理（原理不是很懂的，先看看上篇）

• 任何数和自己异或为0
• 任何数和0异或为自己
• 异或具有交换律

思路

（1）一个出现奇数次

1. 出现偶数次的一异或为0了，对剩下的奇数次数不造成干扰
2. 奇数次（2n+1）的前2n次一异或为0了，对剩下那个数不造成干扰
3.  剩下的那个数就是结果

（2）两个出现奇数次

1. 常规的从头到尾异或一遍，得到数肯定不为0，这个数是那两个出现奇数次的数异或的结果
2. 找出这个数中不为1的那个位pos（在这个位置处，两个奇数次的数肯定不同——要是相同这个位也是0）
3. 整个序列根据位pos的值分成两组（0的一组，1的一组，这样把出现偶数次的分到一组，无碍。出现奇数次的分到两组，正好）
4. 对着两组，利用（1）的方法，解决

细节：如何找到一个二进制中第一个是"1"的位

参考代码：

int Judge(int val, int j)
{
　　int i;
　  for(i=2; i!=j; i*=2)
　　　　val /= 2;
　　return val % 2;
}
#include <stdio.h>
int main()
{
    int val[6] = {4, 3, 1, 56, 3, 1}, i, j;
    int pos = val[0];
    int left=0, right=0;     //分别表示两个奇数次数
    for (i = 1; i < 6; i++)
    {
        pos ^= val[i];      //得出两奇数次数的异或
    }
    for (j = 2; ; j *= 2)
    {
        if (0 != pos % j)   //找出开始为1的位置
            break;
    }
    for (i = 0; i < 6; i++) //根据标志位，分别找出那个奇数次数 
    {
        if ( 0 == Judge(val[i], j))  
            left ^= val[i];
        else
            right ^= val[i];
    }
    printf("%d........%d\n", left, right);
    return 0;
}

 

 另一写法（记录移动次数）

#include <iostream>
using namespace std;
void printOneNum(int *a, int size)
{
    if(size <= 0)
        return;
    int tmpsum = 0;
    for(int i = 0; i < size; ++i)
        tmpsum ^= a[i];
    cout << "hello:" << tmpsum << endl;
    int movestep = 0;
    while(tmpsum % 2 == 0)
    {
        ++movestep;
        tmpsum >>= 1;
    }
    cout << "movestep:" << movestep << endl;
    int left = 0, right = 0;
    for(int i = 0; i < size; ++i)
    {
        int tmp = a[i] << movestep;
        if(tmp % 2 == 0)
            left ^= a[i];
        else
            right ^= a[i];
    }
    cout << right << " " << left << endl;
}
int main()
{
    int a[] = {4, 3, 1, 5, 3, 1};
    int size = sizeof(a) / sizeof(*a);
    printOneNum(a, size);
}