用异或交换数

通常的交换两个变量a,b的过程为

int temp;

temp=a

a=b;

b=temp;

需借助上面的第3个临时变量temp.

采用下面的方法，对于给定两个整数a,b，下面的异或运算可以实现a,b的交换，而无需借助第3个临时变量：

    a = a ^ b;
    b = a ^ b;
    a = a ^ b;

这个交换两个变量而无需借助第3个临时变量过程，其实现主要是基于异或运算的如下性质：

1.任意一个变量X与其自身进行异或运算，结果为0，即X^X=0

2.任意一个变量X与0进行异或运算，结果不变，即X^0=X

3.异或运算具有可结合性，即a^b^c=（a^b）^c=a^（b^c）

4.异或运算具有可交换性，即a^b=b^a

分析：

第一步：    a = a ^ b;

完成后 a变量的结果为a ^ b

第二步：    b = a ^ b;

此时赋值号右边的a保存的是a ^ b的值，那么将赋值号右边的a用a ^ b替换，

得到（a ^ b） ^ b=a ^ (b ^ b)=a ^0=a,

即经过第二步运算后b中的值为a，即b=a，将a换到了b里

第三步：    a = a ^ b;

此时赋值号右边的a保存的仍然是a ^ b的值，不变，而赋值号右边的b已经是a 了，

将赋值号右边的a,b分别进行替换，

即此时赋值号右边a ^ b=（a ^ b）^ a=a ^ b^ a=a ^ a^ b=0^ b=b, 该值赋值给a,即a=b

即经过第三步运算后a中的值为b，即a=b,将b换到了a里

这样经过如上的三步骤，完成了交换两个变量a,b而无需借助第3个临时变量过程。

这个过程等价于如下的过程,：

a=a+b

b=a-b;

a=a-b;

前提是a+b的值不能溢出。

测试程序如下：

int main()
{
    int a = 4, b = 5;
    printf("a=%d b=%d\n", a, b);
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;
    printf("a=%d b=%d\n", a, b);
}

运行结果:
[root@test cs]# ./a.out
a=4 b=5
a=5 b=4
[ 注意：当a和b相等时，该方法不适用]

前面我们谈到了，可用通过异或运算交换两个数，而不需要任何的中间变量。 如下面:

1. void exchange(int &a, int &b)
   
2. {
   
3.     a ^= b;
   
4.     b ^= a;
   
5.     a ^= b;
   
6. }

然而，这里面却存在着一个非常隐蔽的陷阱。

通常我们在对数组进行操作的时候，会交换数组中的两个元素，如exchang(&a[i], &b[j]), 这儿如果i==j了（这种情况是很可能发生的)，得到的结果就并非我们所期望的。

1. void main() 
   
2. {
   
3.    int a[2] = {1, 2};
   
4.    exchange(a[0], a[1]); //交换a[0]和a[1]的值
   
5.    printf("1---a[0]=%d a[1]=%d\n", a[0], a[1]);
   
6.    exchange(a[0], a[0]); //将a[0]与自己进行交换
   
7.    printf("2---a[0]=%d a[1]=%d\n", a[0], a[1]);
   
8. }

 上面那段测试代码的输出是：

1. 1---a[0]=2 a[1]=1
2. 2---a[0]=0 a[1]=1

很意外吧，第一次的交换正确的执行了，但是第二次调用exchange的时候却将a[0]置为了0. 仔细分析，不难发现，这正是我们在exchange里面用异或实现交换所造成的。如果输入a和b是同一个数，exchange里面代码相当于：

1. a ^= a;
   
2. a ^= a;
   
3. a ^= a;

成了a做了3次于自己的异或，其结果当然是0了。

既然这样，我们就不能够在任何使用交换的地方采用异或了，即使要用，也一定要在交换之前判断两个数是否已经相等了，如下：

1.     void exchange(int &a, int &b)
   
2.     {
   
3.         if(a == b) return; //防止&a，&b指向同一个地址；那样结果会错误。
   
4.         a ^= b;
   
5.         b ^= a;
   
6.         a ^= b;
   
7.     }