神奇的抑或運算

感受異或的神奇
MAY 29TH, 2014
異或

什麼是異或？
Wikipedia的解釋：

在邏輯學中，邏輯算符異或（exclusive or）是對兩個運算元的一種邏輯析取類型，符號爲 XOR 或 EOR 或 ⊕（編程語言中常用^）。但與一般的邏輯或不同，異或算符的值爲真僅當兩個運算元中恰有一個的值爲真，而另外一個的值爲非真。轉化爲命題，就是：“兩者的值不同。”或“有且僅有一個爲真。”

定義：

1 ⊕ 1 = 0

0 ⊕ 0 = 0

1 ⊕ 0 = 1

0 ⊕ 1 = 1

真值表：

Y B = 0 B = 1
A = 0 0 1
A = 1 1 0
表達式：

Y = A’ · B + A · B’

解釋：我使用·作爲與，我使用+作爲或，我使用’作爲否(本來應該使用頭上一橫，但是太難編輯了，就使用了’）；

異或有什麼特性？
根據定義我們很容易獲得異或兩個特性：

恆等律：X ⊕ 0 = X 歸零律：X ⊕ X = 0

然後我們使用真值表可以證明：

（1）交換律

A ⊕ B = A’ · B + A · B’

B ⊕ A = B’ · A + B · A’
因爲·與和+或兩個操作滿足交換律，所以：

A ⊕ B = B ⊕ A

（2）結合律

(A ⊕ B) ⊕ C

= (A’ · B + A · B’) ⊕ C

= (A’ · B + A · B’)’ · C + (A’ · B + A · B’) · C ’

= ((A’ · B)’ · (A · B’)’)· C + A’ · B · C ’ + A · B’ · C ’

= ((A + B’) · (A’ + B))· C + A’ · B · C ’ + A · B’ · C ’

= (A · B + A’ · B’) · C + A’ · B · C ’ + A · B’ · C ’

= A · B · C + A’ · B’ · C + A’ · B · C ’ + A · B’ · C ’
你可以使用同樣推導方法得出（請允許我偷懶一下，數學公式敲起來不容易 +_+）：
A ⊕ (B ⊕ C)

= A · B · C + A’ · B’ · C + A’ · B · C ’ + A · B’ · C ’
證明過程中使用瞭如下幾個方法（·與 +或 '否）：

·與 +或交換律：

A · B = B · A

A + B = B + A
·與 +或結合律：

(A · B) · C = A · (B · C)

(A + B) + C = A + (B + C)　
·與 +或分配律：

A · (B + C)= A · B + A · C

A + B · C = (A + B) · (A + C)
摩爾定理：
(A · B)’ = A’ + B’

(A + B)’ = A’ · B’
結論：

交換律：A ⊕ B = B ⊕ A 結合律：A ⊕ (B ⊕ C) = (A ⊕ B) ⊕ C

有了歸零率和結合律，我們就可以輕鬆證明：

自反：A ⊕ B ⊕ B = A ⊕ 0 = A

可能這些特性會很順其自然的理解，但是如果你在解決問題的時候，你可能會忘記異或的這些特性，所以適當的應用可以讓我們加深對異或的理解；
A ⊕ 1 = A’;
A ⊕ 0 = A;
A ⊕ A = 0;
A ⊕ A’ = 1;
異或有什麼神奇之處（應用）？
說明：以下的的異或全部使用符號^

可能你已經被亂七八糟的公式和演算搞的有點煩了，不就是很簡單的異或運算嗎？還解釋的那麼複雜，嘿嘿，不要着急，打好了基礎，你就站在了巨人的肩膀，讓我們開始異或的神奇之旅吧；

（1）快速比較兩個值
先讓我們來一個簡單的問題；判斷兩個int數字a，b是否相等，你肯定會想到判斷a - b == 0，但是如果判斷a ^ b == 0效率將會更高，但是爲什麼效率高呢？就把這個給你當家庭作業吧，考慮下減法是如何實現的；讓我們看看ipv6中的比較；
‘’'c++
static inline int ipv6_addr_equal(const struct in6_addr *a1, const struct in6_addr *a2)
{
return (((a1->s6_addr32[0] ^ a2->s6_addr32[0]) |
(a1->s6_addr32[1] ^ a2->s6_addr32[1]) |
(a1->s6_addr32[2] ^ a2->s6_addr32[2]) |
(a1->s6_addr32[3] ^ a2->s6_addr32[3])) == 0);
}
（2）在彙編語言中經常用於將變量置零：xor a，a；
（3）我們可以使用異或來使某些特定的位翻轉，因爲不管是0或者是1與1做異或將得到原值的相反值；
0 ^ 1 = 1

1 ^ 1 = 0

例如：翻轉10100001的第6位，答案：可以將該數與00100000進行按位異或運算;10100001 ^ 00100000 = 10000001

我們給出一段常用的代碼
unsigned int a, b, mask = 1 << 6;
a = 0xB1; // 10100001
b = a ^ mask; /* flip the 6th bit */
（4）我們使用異或來判斷一個二進制數中1的數量是奇數還是偶數
例如：求10100001中1的數量是奇數還是偶數；答案：1 ^ 0 ^ 1 ^ 0 ^ 0 ^ 0 ^ 0 ^ 1 = 1,結果爲1就是奇數個1，結果爲0就是偶數個1；應用：這條性質可用於奇偶校驗（Parity Check），比如在串口通信過程中，每個字節的數據都計算一個校驗位，數據和校驗位一起發送出去，這樣接收方可以根據校驗位粗略地判斷接收到的數據是否有誤

（5）校驗和恢復
校驗和恢復主要利用的了異或的特性：IF a ^ b = c THEN a ^ c = b 應用：一個很好的應用實例是RAID5，使用3塊磁盤（A、B、C）組成RAID5陣列，當用戶寫數據時，將數據分成兩部分，分別寫到磁盤A和磁盤B，A ^ B的結果寫到磁盤C；當讀取A的數據時，通過B ^ C可以對A的數據做校驗，當A盤出錯時，通過B ^ C也可以恢復A盤的數據。

RAID5的實現比上述的描述複雜多了，但是原理就是使用異或，有興趣的同學看下RAID5

（6）經典題目：不使用其他空間，交換兩個值
a = a ^ b;
b = a ^ b; //a ^ b ^ b = a ^ 0 = a;
a = a ^ b;
這個題目就不用解釋了吧，太大衆題目了，哈哈，但是非常好的使用的了異或的特性；

（7）面試題：互換二進制數的奇偶位；
題目：寫一個宏定義，實現的功能是將一個int型的數的奇偶位互換，例如6的2進製爲00000110，(從右向左)第一位與第二位互換，第三位與第四位互換，其餘都是0不需要交換，得到00001001，輸出應該爲9；

思路：我們可以把我們的問題分爲三步（難道這也是分治法嗎 -。-），第一步，根據原值的偶數位獲取到目標值的奇數位，並把不需要的位清零；第二步，根據原值的奇數位獲取到目標值的偶數位，並把不需要的位清零；第三步：把上述兩個殘缺的目標值合併成一個完整的目標值；

代碼爲：

//假設 int 佔兩個字節，16位；
#include
#include
using namespace std;
#define N(n) ((n<<1)&(0xAAAA))|((n>>1)&(0x5555))
void main(){
int k = N(6);
cout << k << endl;
}
解釋： 1.爲簡化說明，我們以4位二進制碼爲例，0xAAAA 我們用 1010 代替；0x5555 我們用 0101 代替； 2.(n<<1)&(1010) 把n先左移1位，再與1010做與運算，只保留移位之後的偶數位的值，奇數位全爲0，實際上是隻保留了n的奇數位的值，並把它們交換到了偶數位上。比如 n = 0110 , n<<1 = 1100, (n<<1) & 1010 = 1000 ; 3.(n>>1)&(0101) 把n右移一位，再與 0101 做與運算，只保留移位之後的奇數位的值，偶數位全爲0，實際是隻保留n 的偶數位的值，並把它們交換到對應的奇數位上。n = 0110； n>>1 = 0011； (n>>1) & 0101 = 0001； 4.最後做或運算（相加），得到1001。

（7）最最常出現的面試題：一個整型數組裏除了N個數字之外，其他的數字都出現了兩次，找出這N個數字；
比如，從{1, 2, 3, 4, 5, 3, 2, 4, 5}中找出單個的數字： 1

讓我們從最簡單的，找一個數字開始；

題目：（LeetCode 中通過率最高的一道題） Single Number: Given an array of integers, every element appears twice except for one. Find that single one. Note:Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory? 思路：拿到這個題目，本能的你會使用排序（數字文字我們常常需要排序），排序後可以來判斷是否數字成對出現，思路很明顯，但是排序的算法上限是 O(nlogn)，不符合題目要求；

學習了強大的異或，我們可以輕鬆的使用它的特性來完成這道題目：（1）A ^ A = 0; （2）異或滿足交換律、結合律；所有假設有數組：A B C B C D A 使用異或：
A ^ B ^ C ^ B ^ C ^ D ^ A
= A ^ A ^ B ^ B ^ C ^ C ^ D
= 0 ^ 0 ^ 0 ^ D
= 0 ^ D
= D
是不是很神奇？時間複雜度爲O(n)，當然是線性的，空間複雜度O(1)；

代碼：
class Solution {
public:
int singleNumber(int A[], int n) {
//特殊情況1,2
if(n<=0) return -1;
if(n==1) return A[0];

    int result = 0;
    for (int i = 0; i < n; i ++) {
        result = result ^ A[i];
    }
    return result;
}

};
接下來讓我們增加一些難度：

題目：一個整型數組裏除了兩個數字之外，其他的數字都出現了兩次。請寫程序找出這兩個只出現一次的數字？

思路：第一步：肯定還是像我們上面的解法一樣，所有數進行異或，不過最終得到的結果是 a 和 b（假設 a 和 b 是落單的數字）兩個值的異或結果 aXORb，沒有直接得到 a 和 b 的值；

第二步：想辦法得到 a 或者 b，假設 aXORb 爲 00001001（F肯定不爲0），根君 aXORb 的值我們發現，值爲1的位（比如從右向左第一位）表示在此位上 a 和 b 的值不同；所以，根據這個特點，我們找出來所有第一位爲1的數進行異或，得到的就是 a 或者 b；

第三步：aXORb = a ^ b，假設我們已經找到了 a，根據異或特性，我們知道，b = aXORb ^ a；這樣我們就可以找出 b；所以我們只需要循環兩次；

這樣我們的時間複雜度是 O(n)，空間複雜度是 O(1) 代碼：
#include
#include <assert.h>
using namespace std;

int getFirstOneBit(int num) //輸出 num 的低位中的第一個 1 的位置
{
return num & ~(num - 1); // num 與 -num 相與找到
}

void findTwo(int *array, int length){
int aXORb = 0;
int firstOneBit = 0;
int a = 0;
int b = 0;
for (int i = 0; i < length; i++) {
aXORb ^= array[i];
}
assert(aXORb != 0); //保證題目要求，有兩個single的數字
firstOneBit = getFirstOneBit(aXORb);
for (int i = 0; i < length; ++i) {
if(array[i] & firstOneBit) {
a ^= array[i];
}
}
b = aXORb ^ a;
cout << "a: " << a << endl;
cout << "b: " << b << endl;
}

int main()
{
int array1[] = {2, 5, 8, 2, 5, 8, 6, 7};
findTwo(array1, 8);
return 0;
}
接下來讓我們再增加一些難度：

題目：一個整型數組裏除了三個數字之外，其他的數字都出現了兩次。請寫程序找出這兩個只出現一次的數字？

思路：

第一步：肯定還是像我們上面的解法一樣，所有數進行異或，不過最終得到的結果是 a、b 和 c（假設 a、b 和 c 是落單的數字）三個值的異或結果 aXORbXORc，沒有直接得到 a、b 和 c 的值；

第二步：想辦法得到 a、b 和 c 中的一個，讓偶們把問題簡化一下；

假設一個數組中有3個不同的數字 a、b 和 c，已知 aXORbXORc = a ^ b ^ c ，求 a、b 和 c 。

思路： 1. 根據題目 aXORbXORc ^ a = b ^ c; aXORbXORc ^ b = a ^ c; aXORbXORc ^ c = a ^ b; 因爲：(b ^ c) ^ (a ^ c) ^ (a ^ b) = 0; 所以：(aXORbXORc ^ a) ^ (aXORbXORc ^ b) ^ (aXORbXORc ^ c) = 0;

下一步是關鍵：假設 X ^ Y ^ Z = 0，則 X Y Z 三個數的低位第一位爲1的位置兩個相同，一個不同；比如 X: 00001000, Y: 00000100, Z: 00001100 Y和Z的低位第一位都是00000100， X的低位第一位是00001000；這一步可以使用倒推法證明：已知：三個數的低位第一位爲1的位置有三種情況，一種就是全相同，一種就是兩個不同，一個不同，一種就是三個不同；（1）如果是全相同，則 X ^ Y ^ Z != 0 (1 ^ 1 ^ 1 = 1)，與前提X ^ Y ^ Z = 0矛盾，不成立；（2）如果三個不同，則 X ^ Y ^ Z != 0 (1 ^ 0 ^ 0 = 1)，與前提X ^ Y ^ Z = 0矛盾，不成立；所以結果是：兩個不同，一個不同

(aXORbXORc ^ a) ^ (aXORbXORc ^ b) ^ (aXORbXORc ^ c) = 0; 所以三個數(aXORbXORc ^ a)、(aXORbXORc ^ b) 和 (aXORbXORc ^ c) 的低位第一位爲1的位置兩個相同，一個不同；那麼我們獲取到這三個數的低位第一位爲1的位置後，進行異或並取低位第一位爲1的位置，就可以找到三個中“一個不同”的低位第一位爲1的位置，假設這個值爲 firstOneBit。

遍歷這三個數(aXORbXORc ^ a)、(aXORbXORc ^ b) 和 (aXORbXORc ^ c)，如果發現某個數異或 aXORbXORc 等於 firstOneBit，這個數就是“一個不同”的那個數；

找到了一個數，剩下的兩個數，我們就可以通過上面的方法找出來；

第三步：完成了第二步的簡化題，我們回到我們的問題，我們的問題比簡化的問題多了一個成對的干擾數據，我們可以使用異或要去除干擾數據（記住，我們這個題目都是用異或i去除干擾數據的）；

這樣我們的時間複雜度還是 O(n)，空間複雜度是 O(1)

代碼如下：
‘’'c++
#include
#include <assert.h>
using namespace std;

int getFirstOneBit(int num) //輸出 num 的低位中的第一個 1 的位置
{
return num & ~(num - 1); // num 與 -num 相與找到
}

int findOne(int *array, int length) {
int aXORbXORc = 0;
int c = 0;
int firstOneBit = 0;
for (int i = 0; i < length; ++i) {
aXORbXORc ^= array[i];
}
for (int i = 0; i < length; ++i) {
firstOneBit ^= getFirstOneBit(aXORbXORc ^ array[i]); //使用異或會排除掉不相干的元素
}
// firstOneBit = getFirstOneBit(a ^ b) ^ getFirstOneBit(a ^ c) ^ getFirstOneBit(b ^ c);

firstOneBit = getFirstOneBit(firstOneBit); //獲取到最低位下面要用

for (int i = 0; i < length; ++i) {
    if (getFirstOneBit(aXORbXORc ^ array[i]) == firstOneBit) {
        c ^= array[i]; //使用異或會排除掉不相干的元素
    }
}
cout << "c: " << c << endl;
return c;

}

int main()
{
int array1[] = {2, 5, 8, 2, 5, 8, 6, 7, 1};
int c = findOne(array1, 9);
int array2[] = {2, 5, 8, 2, 5, 8, 6, 7, 1, c}; //爲了更好重用函數，我重新定義了一個數組讓大家理解
findTwo(array2, 10);
return 0;
}

寫這篇文檔參考了《離散數學與應用》課本，參考了別人多個博客，如果我參考了你的博客，但沒有註明出處，請聯繫告知，有錯誤的地方，希望可以指出來，也希望大家有更多的補充，非常感謝。

神奇的抑或運算

二叉樹非遞歸遍歷（前中後）

取餘運算規律

二叉樹，遞歸實現

ACM算法入門訓練指南

c++之cout的一些輸出格式控制（持續完善

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結