程式設計技巧--位運算的巧妙運用(1)
作者:yunyu5120
這是我的這一系列文章的第一篇,主要講述我學習過程中積累的一些程式設計技巧,由於我也是一個初學者,高手莫笑。這一篇主要講解位運算的基礎知識魚與其簡單應用,我主要以C/C++語言講述,其他語言可以類推。如果你已經對位運算基礎和應用十分熟悉,那麼本文並不適合你。
我相信還是有一部分人對位運算還不是很瞭解,我希望你在看了本博文之後能對位運算有深刻的瞭解,並運能夠用自如,能夠體會到程式設計的樂趣。
“寫程式,位運算是必要的嗎?”
這個問題問的好,其實位運算並不是必要的,有什多方法可以可以代替位運算,但是位運算其特有的對程式的優化特點是無法替代的!當然如果你在寫Windows應用程式,其中呼叫的一些Windows APi 你就必須用到位運算,如最簡單的MessageBox。當然其中牽扯到的位運算過於簡單,就是簡單的或運算。想想當初寫的第一個windows程式用到MessageBox竟然出現了一個windows視窗,而不是那黑糊糊的Console,讓我興奮了還一段時間!可是當時的我也不知道這裡面牽扯的很多知識,甚至什麼是API都不知道!
我們在學習C/C++的時候書本上對位運算的相關知識講得很少,就是簡單的“或與非”。如果你的記性好那麼你還會記得在位運算中還有一個運算叫做 “異或”運算和移位運算。不知道你現在對位運算的基礎是否還清楚,我在這裡假設我們都忘了位運算的基礎,所以下面我們對位運算進行復習一下。
C/C++語言提供的位運算子有:
運算子 | 含義 | 功能 |
& | 按位與 | 如果兩個相應的二進位制位都為1,則該位的結果值為1;否則為0。 |
| | 按位或 | 兩個相應的二進位制位中只要有一個為1,該位的結果值為1。 |
∧ | 按位異或 | 若參加運算的兩個二進位制位同號則結果為0(假)異號則結果為1(真) |
~ | 取反 | ~是一個單目(元)運算子,用來對一個二進位制數按位取反,即將0變1,將1變0。 |
<< | 左移 | 左移運算子是用來將一個數的各二進位制位全部左移N位,右補0。 |
>> | 右移 | 表示將a的各二進位制位右移N位,移到右端的低位被捨棄,對無符號數,高位補0。 |
位運算的結果演示:
位運算 | 或 “|” or | 與 “&”and | 非 “~” not | 異或 “^” xor |
運算元1 | 01010101 | 11010101 | 10101010 | 10000001 |
運算元2 | 00101010 | 10101010 | (無) | 01111111 |
也能算結果 | 01111111 | 10000000 | 01010101 | 11111110 |
好了看了上面的兩個表格,相信你已經對位運算有所瞭解了,那麼接下來,我們就來講講位運算的應用。
1、 用於整數的奇偶性判斷
想想,我們要判斷一個數的奇偶性,在沒用位運算之前我們可以用下列的程式碼來實現:
[cpp] view plain copy print?- template<class Type>
- bool Parity(Type value)
- {
- if(value % 2 == 0)
- returnfalse;
- else
- returntrue;
- }
- //加以優化
- template<class Type>
- inlinebool Parity(Type value)
- {
- return (value % 2 != 0);
- }
template<class Type>
bool Parity(Type value)
{
if(value % 2 == 0)
return false;
else
return true;
}
//加以優化
template<class Type>
inline bool Parity(Type value)
{
return (value % 2 != 0);
}
要知道,上面的程式碼我們使用的是對2取餘,如果運算元value是小數的話,還勉強行得通,但是value是一個上百萬的大數,那麼這就白白浪費了CPU的大量時間,程式的效率和效能就很差。我們知道任何數在計算機儲存中都是以二進位制儲存的,細心的你就會發現在二進位制的最小一位有個特點,為0就是偶數,為1就是奇數,按照這個原理我們根本沒必要讓我們的CPU大哥白白做那麼多的工作,只要一步判斷就可以了。接下來就讓我們看看位運算的精妙之處!
那麼我們的目的就是判斷最小位是0還是1,可是我們怎麼判斷呢?我們要用位運算阿里判斷,就是與或非。在上面的複習之中我們只說了位運算的計算方法,並沒有說其用處。那麼在這裡我們用到的就是“與”!與運算特有的一個功能就是判斷指定位上的值(0或1)。我們來看下面的表格(與運算)。
運算元1 | 10101010 | 01010101 | 11111111 | 11111110 |
運算元2 | 00000001 | 00000001 | 00000001 | 00000001 |
運算結果 | 00000000 | 00000001 | 00000001 | 00000000 |
我們要注意一下這裡的 運算元2 ,它只有最低位是1,其餘位都是0,這就是關鍵所在,運算元1是隨機值。我們看看結果只會有兩種結果:0或1。這個結果就取決於運算元1的最低位,它為1時就為1,為0時就為0.
“那麼我要判斷的是第二位呢?”
好!那我們就把運算元2改為 00000010 那麼結果就只會有 00000000 或 00000010 其結果取決於第二位。
有了這個基礎那麼我們來看看怎麼用位運算判斷奇偶性吧:
- template<class Type>
- bool Parity(Type value)
- {
- if(value & 0x0001 == 0)
- returnfalse;
- else
- returntrue;
- }
- //加以優化
- template<class Type>
- inlinebool Parity(Type value)
- {
- return (value & 1 != 0);
- }
- //在簡化
- #define PARITY(value) (value&1)
template<class Type>
bool Parity(Type value)
{
if(value & 0x0001 == 0)
return false;
else
return true;
}
//加以優化
template<class Type>
inline bool Parity(Type value)
{
return (value & 1 != 0);
}
//在簡化
#define PARITY(value) (value&1)
使用a%2來判斷奇偶性和a & 1是一樣的作用,但是a & 1要快好多。
2、 判斷n是否是2的整數冪
所謂2的整數冪就是指 1(2的0次冪),2,4,8,16,32,64,128,256,512,1024,2048.............等數字,若何判斷一個數是否是這樣的數呢?我們看看不用位運算的計算方法:
[cpp] view plain copy print?- #include "math.h"
- template<class Type>
- bool IsPowerOfTwo(Type value)
- {
- for(int i = 0,l = 8*sizeof(value); i < l ;i++)
- {
- if(pow(2,i) == value)
- {
- returntrue;
- }
- }
- returnfalse;
- }
#include "math.h"
template<class Type>
bool IsPowerOfTwo(Type value)
{
for(int i = 0,l = 8*sizeof(value); i < l ;i++)
{
if(pow(2,i) == value)
{
return true;
}
}
return false;
}
在這個演算法中,我們使用了一個迴圈。其原理非常簡單就是一一的對比,但是其中還呼叫了數學函式庫,效率大大降低。接下來我們講講怎樣用位運算來判斷。我們首先要研究一下這些數的特性,請看下錶(與運算):
2的冪 | 8 | 16 | 32 | 64 |
n | 00001000 | 00010000 | 00100000 | 01000000 |
n-1 | 00000111 | 00001111 | 00011111 | 00111111 |
與結果 | 00000000 | 00000000 | 00000000 | 00000000 |
我們發現 n &(n-1) = 0 我們可以 用邏輯非 !(n&(n-1)) = 1 。那是不是這樣就可以了呢,你會發現 !(0&(0-1)) = 1 但是 0並不是 2的正整數冪。我們可以用 邏輯與 (!(n&(n-1) && n) = 1;請看下面的程式碼:
[cpp] view plain copy print?- template<class Type>
- inlinebool IsPowerOfTwo(Type n)
- {
- if(((!(n&(n-1))) && n) == 1)
- returntrue;
- else
- returnfalse;
- }
- //簡化
- #define ISPOWEROFTWO(n) ((!(n&(n-1)) ) && n)
template<class Type>
inline bool IsPowerOfTwo(Type n)
{
if(((!(n&(n-1))) && n) == 1)
return true;
else
return false;
}
//簡化
#define ISPOWEROFTWO(n) ((!(n&(n-1)) ) && n)
3、 統計n在二進位制中1的個數
樸素的統計辦法是:先判斷n的奇偶性,為奇數時計數器增加1,然後將n右移一位,重複上面步驟,直到移位完畢。
[cpp] view plain copy print?- template<class Type>
- inlinebool Parity(Type value)
- {
- return (value % 2 != 0);
- }
- template<class Type>
- inlineint CountOne(Type value)
- {
- if(value != 0)
- {
- return Parity(value) + CountOne(value >> 1);
- }
- return 0;
- }
template<class Type>
inline bool Parity(Type value)
{
return (value % 2 != 0);
}
template<class Type>
inline int CountOne(Type value)
{
if(value != 0)
{
return Parity(value) + CountOne(value >> 1);
}
return 0;
}
樸素的統計辦法是比較簡單的,那麼我們來看看比較高階的辦法。
舉例說明,
考慮2位整數 n=11(十進位制為3),裡邊有2個1,先提取裡邊的偶數位10,奇數位01,把偶數位右移1位,然後與奇數位相加,因為每對奇偶位相加的和不會超過“兩位”,所以結果中每兩位儲存著數n中1的個數,那麼把 n 計算之後得到的值為:(10>>1)+01 = 01 + 01 = 10, 把10換成十進位制就是 2,2就代表 n(3)=11 中有兩個1!
相應的如果n是四位整數 n=0111(十進位制7),先以“一位”為單位做奇偶位提取:偶數位 0010,奇數位0101。然後偶數位移位(右移1位)再相加:(0010>>1)+0101=0110;再用0110以“兩位”為單位做奇偶提取:偶數為0100,奇數位0010。偶數位移位(這時就需要移2位)再相加:(0100>>2)+0010=0011,因為此時每對奇偶位的和不會超過“四位”,所以結果中儲存著n中1的個數:(0100>>2)+0010=0011 把0011換成十進位制就是3,3就是n(7)=0111中有3個1。
依次類推可以得出更多位n的演算法。整個思想類似分治法。
在這裡就順便說一下常用的二進位制數:
二進位制數 | 二進位制值 | 用處 |
0xAAAAAAAA | 10101010101010101010101010101010 | 偶數位為1,以1位為單位提取奇位 |
0x55555555 | 01010101010101010101010101010101 | 奇數位為1,以1位為單位提取偶位 |
0xCCCCCCCC | 11001100110011001100110011001100 | 以“2位”為單位提取奇位 |
0x33333333 | 00110011001100110011001100110011 | 以“2位”為單位提取偶位 |
0xF0F0F0F0 | 11110000111100001111000011110000 | 以“8位”為單位提取奇位 |
0x0F0F0F0F | 00001111000011110000111100001111 | 以“8位”為單位提取偶位 |
0xFFFF0000 | 11111111111111110000000000000000 | 以“16位”為單位提取奇位 |
0x0000FFFF | 00000000000000001111111111111111 | 以“16位”為單位提取偶位 |
[cpp] view plain copy print?
- int CountOne(unsigned int n)
- {
- //0xAAAAAAAA,0x55555555分別是以“1位”為單位提取奇偶位
- n = ((n & 0xAAAAAAAA) >> 1) + (n & 0x55555555);
- //0xCCCCCCCC,0x33333333分別是以“2位”為單位提取奇偶位
- n = ((n & 0xCCCCCCCC) >> 2) + (n & 0x33333333);
- //0xF0F0F0F0,0x0F0F0F0F分別是以“4位”為單位提取奇偶位
- n = ((n & 0xF0F0F0F0) >> 4) + (n & 0x0F0F0F0F);
- //0xFF00FF00,0x00FF00FF分別是以“8位”為單位提取奇偶位
- n = ((n & 0xFF00FF00) >> 8) + (n & 0x00FF00FF);
- //0xFFFF0000,0x0000FFFF分別是以“16位”為單位提取奇偶位
- n = ((n & 0xFFFF0000) >> 16) + (n & 0x0000FFFF);
- return n;
- }
int CountOne(unsigned int n)
{
//0xAAAAAAAA,0x55555555分別是以“1位”為單位提取奇偶位
n = ((n & 0xAAAAAAAA) >> 1) + (n & 0x55555555);
//0xCCCCCCCC,0x33333333分別是以“2位”為單位提取奇偶位
n = ((n & 0xCCCCCCCC) >> 2) + (n & 0x33333333);
//0xF0F0F0F0,0x0F0F0F0F分別是以“4位”為單位提取奇偶位
n = ((n & 0xF0F0F0F0) >> 4) + (n & 0x0F0F0F0F);
//0xFF00FF00,0x00FF00FF分別是以“8位”為單位提取奇偶位
n = ((n & 0xFF00FF00) >> 8) + (n & 0x00FF00FF);
//0xFFFF0000,0x0000FFFF分別是以“16位”為單位提取奇偶位
n = ((n & 0xFFFF0000) >> 16) + (n & 0x0000FFFF);
return n;
}
看起來似乎採用位運算的程式碼比樸素方法程式碼要複雜的多,但是在效能上有著樸素方法無法比擬的優越性,只要四步簡單的運算就能達到目的,而樸素方法不是用迴圈就是遞迴,這大大降低了CPU的運算效能。
4、對於正整數的模運算(注意,負數不能這麼算)
先說下比較簡單的:
乘除法是很消耗時間的,只要對數左移一位就是乘以2,右移一位就是除以2,據說用位運算效率提高了60%。
乘2^k 眾所周知: n<<k。所以你以後還會傻傻地去敲2566*4的結果10264嗎?直接2566<<2就搞定了,又快又準確。
除2^k眾所周知: n>>k。
那麼 mod 2^k 呢?(對2的倍數取模)
n&((1<<k)-1)
用通俗的言語來描述就是,對2的倍數取模,只要將數與2的倍數-1做按位與運算即可。
好!方便理解就舉個例子吧。
思考:如果結果是要求模2^k時,我們真的需要每次都取模嗎?
在此很容易讓人想到快速冪取模法。
快速冪取模演算法
經常做題目的時候會遇到要計算 a^b mod c 的情況,這時候,一個不小心就TLE(演算法計算超時,ACM題目測試結果常見問題)了。那麼如何解決這個問題呢?位運算來幫你吧。
首先介紹一下秦九韶演算法:(數值分析講得很清楚)
把一個n次多項式f(x) = a[n]x^n+a[n-1]x^(n-1)+......+a[1]x+a[0]改寫成如下形式:
f(x) = a[n]x^n+a[n-1]x^(n-1))+......+a[1]x+a[0]
= (a[n]x^(n-1)+a[n-1]x^(n-2)+......+a[1])x+a[0]
= ((a[n]x^(n-2)+a[n-1]x^(n-3)+......+a[2])x+a[1])x+a[0]
=. .....
= (......((a[n]x+a[n-1])x+a[n-2])x+......+a[1])x+a[0].
求多項式的值時,首先計算最內層括號內一次多項式的值,即
v[1]=a[n]x+a[n-1]
然後由內向外逐層計算一次多項式的值,即
v[2]=v[1]x+a[n-2]
v[3]=v[2]x+a[n-3]
......
v[n]=v[n-1]x+a[0]
這樣,求n次多項式f(x)的值就轉化為求n個一次多項式的值。
好!有了前面的基礎知識,我們開始解決問題吧
由(a × b) mod c=( (a mod c) × b) mod c.
我們可以將 b先表示成就:
b = a[t] × 2^t + a[t-1]× 2^(t-1) + …… + a[0] × 2^0. (a[i]=[0,1]).
這樣我們由 a^b mod c = (a^(a[t] × 2^t + a[t-1] × 2^(t-1) + …a[0] × 2^0) mod c.
然而我們求 a^( 2^(i+1) ) mod c=( (a^(2^i)) mod c)^2 mod c .求得。
具體實現如下:
使用秦九韶演算法思想進行快速冪模演算法,簡潔漂亮
// 快速計算 (a ^ p) % m 的值 [cpp] view plain copy print?
- __int64 FastM(__int64 a, __int64 p, __int64 m)
- {
- if (p == 0) return 1;
- __int64 r = a % m;
- __int64 k = 1;
- while (p > 1)
- {
- if ((p & 1)!=0)
- {
- k = (k * r) % m;
- }
- r = (r * r) % m;
- p >>= 1;
- }
- return (r * k) % m;
- }
__int64 FastM(__int64 a, __int64 p, __int64 m) { if (p == 0) return 1; __int64 r = a % m; __int64 k = 1; while (p > 1) { if ((p & 1)!=0) { k = (k * r) % m; } r = (r * r) % m; p >>= 1; } return (r * k) % m; }
5、計算掩碼
什麼是掩碼?掩碼是一串二進位制程式碼對目標欄位進行位與運算,遮蔽當前的輸入位。用於從一個或多個位元組中選出的位的集合。
舉個例子:
我們有一個IP地址:192.168.1.111 對應二進位制:11000000.10101000.00000001.01101111。
我們讓這個IP位與:255.255.255.0 對應二進位制:11111111.11111111.11111111.00000000。
可以得到子網地址:192.168.1.0 對應二進位制:11000000.10101000.00000001.00000000。
在例子中我們通過觀察二進位制碼就知道,這個過程就是拿到IP的前三個位元組的資料資訊,這裡用到的255.255.255.0就是掩碼,也就是我們常說的子網掩碼。通過子網掩碼可以輕鬆的得到子網地址。那麼通過掩碼我們就可以輕鬆的得到多個位元組中指定的位的集合。
我們現在有一個需求:獲得數x的低n位的集合。
假設 x = 233 n= 6,我們就知道計算方法:233的二進位制是 11101001,所以結果集為 11101001&00111111 =00101001 十進位制為 41。在這個計算中233可以輕易改變,但是 00111111 已經指定 n = 6,要可以讓n也隨意改變怎麼辦呢?
我們用位運算的思維就可以得到 n = 6 時 00111111 可以表示為 (1 << 6) - 1
那麼掩碼的計算公式就為:(1 << n) - 1
現在根據需求可以寫出模版函式如下:
[cpp] view plain copy print?
- template<class Type>
- inline Type LowByte(Type x, int n)
- {
- return x & ((1 << n) - 1);
- }
- //簡化
- #define LOWBYTE(x,n) x & ((x << n) - 1)
template<class Type> inline Type LowByte(Type x, int n) { return x & ((1 << n) - 1); } //簡化 #define LOWBYTE(x,n) x & ((x << n) - 1)
如果是高位集合呢?我們只需要把掩碼左移就可以了:n = 6 時 00111111<<2 公式為:((1 << 6) - 1)<<2
[cpp] view plain copy print?
- template<class Type>
- inline Type HeightByte(Type x, int n)
- {
- return x & (((1 << n) - 1) << (sizeof(x)-n));
- }
- //簡化
- #define HEIGHTBYTE(x,n) x & (((1 << n) - 1) << (sizeof(x)-n))
template<class Type> inline Type HeightByte(Type x, int n) { return x & (((1 << n) - 1) << (sizeof(x)-n)); } //簡化 #define HEIGHTBYTE(x,n) x & (((1 << n) - 1) << (sizeof(x)-n))
6、子集
假設我們有一個集合 mask ={‘c’,‘b’,‘a’},要求列出集合的所有子集。我們可以使用位運算思想,把集合的元素的有無看成二進位制的0和1那麼我們展開舉例:
{‘c’,‘b’,‘a’}
0 0 1 1 {‘a’}
0 1 0 2 {‘b’}
0 1 1 3 {‘b’,‘a’}
... ... ...
1 1 1 7 {‘c’,‘b’,‘a’}
二進位制 十進位制 對應子集
枚舉出一個集合的子集。設原集合為mask,則下面的程式碼就可以列出它的所有子集:
for (i = mask ; i ; i = (i - 1) & mask) ;
很漂很漂亮吧。