只用位运算来实现整数的加减乘除四则运算 （转载，还没有来得及整理！！！！）

听同学百度二面中，不准用四则运算操作符来实现四则运算。一想就想到了计算机组成原理上学过的。位运算的思想可以应用到很多地方，这里简单的总结一下用位运算来实现整数的四则运算。

首先回忆计算机组成原理学过的内容，数字在机器ALU运算逻辑单元内部是以补码形式进行运算的，因为补码有两个优势：
1、能做到符号位和数值部分一起运算，这样无需单独考虑符号。

2、能把减法运算转化为加法运算来处理。

3、补码的没有正0和负0之分，所以表示范围比原码和反码多1个。

问题一： 位运算实现加法

不管是十进制加法还是二进制加法，其加的的过程在每一位看分为‘和’、‘进位’两个部分。‘和’要留在当前位，‘进位’加入到下一位。

我们现在关注二进制加法。发现一个特点。

位的异或运算跟求'和'的结果一致：

异或 1^1=0 1^0=1 0^0=0

求和 1+1=0 1+0=1 0+0=0

位的与运算跟求'进位‘的结果一致：

位与 1&1=1 1&0=0 0&0=0

进位 1+1=1 1+0=0 0+0=0

于是我们决定用异或运算和与运算来表示加法。下面是两种形式的实现。

[cpp] view plain copy

1. int add(int a, int b) //递归形式  
2. {  
3.     if(b==0) //递归结束条件：如果右加数为0，即不再有进位了，则结束。  
4.         return a;  
5.     int s = a^b;  
6.     int c = (a&b)<<1; //进位左移1位，达到进位的目的。  
7.     return add(s, c); //再把'和'和'进位'相加。递归实现。  
8. }  

[cpp] view plain copy

1. int add(int a, int b) //非递归形式  
2. {  
3.     int s, c;  
4.     while(b != 0)  
5.     {  
6.         s = a^b;  
7.         c = (a&b)<<1;  
8.         a = s;  
9.         b = c;  
10.     }  
11.     return a;  
12. }  

问题二： 位运算实现减法

   减法其实是用加法来实现的。在ALU中，当我求a-b，其实是求[a-b]补。因为有[a-b]补=[a]补 - [b]补= [a]补+[-b]补。所以我就要先求出-b。求一个数的负的操作是将其连符号位一起取反然后加1。

   于是有办法做减法了：先把减数求负，然后做加法。

[cpp] view plain copy

1. int negtive(int i)  
2. {  
3.     return add(~i, 1);  
4. }  

[cpp] view plain copy

1. int subtraction(int a, int b) //减法运算：利用求负操作和加法操作  
2. {  
3.     return add(a, negtive(b));  
4. }  

问题三： 位运算实现乘法

乘法操作时即使用补码也要需要考虑符号位了，所以我要先把符号拿出来单独计算。为了方便，先引入两个工具函数，

[cpp] view plain copy

1. int getsign(int i) //取一个数的符号，看是正还是负  
2. {  
3.     return (i>>31);  
4. }  
5.   
6. int bepositive(int i) //将一个数变为正数，如果本来就是正，则不变；如果是负，则变为相反数。注意对于-2147483648，求负会溢出。  
7. {  
8.     if(i>>31)  
9.         return negtive(i);  
10.     else  
11.         return i;  
12. }  

做乘法的第一种思路：

很直观，就是用循环加法替代乘法。a*b，就是把a累加b次。时间复杂度为O(N)。

[cpp] view plain copy

1. int multiply(int a, int b)  
2. {  
3.     bool flag = true;  
4.     if(getsign(a) == getsign(b)) //积的符号判定  
5.         flag = false;  
6.   
7.     a = bepositive(a);//先把乘数和被乘数变为正数  
8.     b = bepositive(b);  
9.     int ans = 0;  
10.     while(b)  
11.     {  
12.         ans = add(ans, a);  
13.         b = subtraction(b, 1);  
14.     }  
15.   
16.     if(flag)  
17.         ans = negtive(ans);  
18.     return ans;  
19. }  

做乘法的第二种思路：

在二进制数上做乘法，如下图：

这一过程就是根据乘数的每一位为0或1时，将被乘数错位的加在积上。时间复杂度为O(logN)。

[cpp] view plain copy

1. int multiply(int a, int b)  
2. {  
3.     bool flag = true;  
4.     if(getsign(a) == getsign(b)) //积的符号判定  
5.         flag = false;  
6.   
7.     a = bepositive(a);  
8.     b = bepositive(b);  
9.     int ans = 0;  
10.     while(b)  
11.     {  
12.         if(b&1)  
13.             ans = add(ans, a);  
14.         a = (a<<1); //把a错位加在积上  
15.         b = (b>>1); //从最低位开始依次判断b的每一位  
16.     }  
17.   
18.     if(flag)  
19.         ans = negtive(ans);  
20.     return ans;  
21. }  

问题四： 位运算实现除法

做除法的第一种思路：

也比较直观，从被除数上减去除数，看能减多少次之后变得不够减。时间复杂度为O(N)。

[cpp] view plain copy

1. int division(int a, int b)  
2. {  
3.     if(b==0)  
4.         return 0;  
5.   
6.     bool flag = true;  
7.     if(getsign(a) == getsign(b)) //积的符号判定  
8.         flag = false;  
9.   
10.     a = bepositive(a);  
11.     b = bepositive(b);  
12.   
13.     int n = 0;  
14.     a = subtraction(a, b);  
15.     while(a>=0)  
16.     {  
17.         n = add(n, 1);  
18.         a = subtraction(a, b);  
19.     }  
20.   
21.     if(flag)  
22.         n = negtive(n);  
23.     return n;  
24. }  

做除法的第二种思路：

第一种方法实在太慢了。减法得减的快一些，不能一个一个减，于是采用类似二分法的思路，从除数*最大倍数开始测试，如果比被除数小，则要减去。下一回让除数的倍数减少为上一次倍数的一半，这样的直到倍数为1时，就能把被除数中所有的除数减去，并得到商。时间复杂度降低到O(logN)。

[cpp] view plain copy

1. int divide(int dividend, int divisor) {  
2.     bool flag = true;  
3.     if(getsign(dividend) == getsign(divisor)) //积的符号判定  
4.         flag = false;  
5.   
6.     unsigned int x = bepositive(dividend);  
7.     unsigned int y = bepositive(divisor);  
8.   
9.     int ans=0;  
10.     int i=31;  
11.     while(i>=0)  
12.     {    
13.         //比较x是否大于y*(1<<i)=(y<<i)，避免直接比较，因为不确定y*(1<<i)是否溢出    
14.         if( (x>>i) >= y)  //如果够减  
15.         {  
16.             ans = add(ans, (1<<i));   
17.             x = subtraction(x, (y<<i));  
18.         }  
19.         i = subtraction(i, 1);  
20.     }   
21.     if(flag)  
22.         ans = negtive(ans);  
23.     return ans;  
24. }  

注意细节：

1、注意考虑除法运算的特殊情况：除数不为0。

2、int整型的表示范围是-2147483648~+2147483647。所以在求负的时候，有一个数-2147483648是不可以求负的，因为int无法表示+2147483648这个数。对于乘法运算，如果出现了这个数，运算就会溢出。对于除法操作，如果被除数是-2147483648，那么不能直接求负。所以最好采用无符号数来进行运算。

3、2^31，2^30,......,64,32,16,8,4,2,1。为什么尝试用这样的倍数做减法就能把所有除数都减去呢？从二进制数的角度来看，这些权值就可以构成所有的整数，组成倍数不会有遗漏。从折半的思想来看，这样是一个逐步折半细化的过程。

有了上面的四则运算，再扩展别的运算就很容易了。

附加问题：只用加法实现1+2+3+...+n，

（循环、判断语句也不用）

1、利用递归来代替循环结构；
2、利用&&与运算的特性来代替if结构。

[cpp] view plain copy

1. int add(int n, int &sum)    
2. {    
3.     n && add(n-1, sum);    
4.     return (sum += n);    
5. }    

或者

[cpp] view plain copy

1. int  sum(int n)  
2. {  
3.     int k;  
4.     ((1 == n)&&(k = 1)) || (k = sum(n-1) + n);  
5.     return k;  
6. } 
   

加法运算：

[cpp] view plain copy

1. int AddWithoutArithmetic(int num1,int num2)  
2. {  
3.     if(num2==0) return num1;//没有进位的时候完成运算  
4.     int sum,carry;  
5.     sum=num1^num2;//完成第一步没有进位的加法运算  
6.     carry=(num1&num2)<<1;//完成第二步进位并且左移运算  
7.     return AddWithoutArithmetic(sum,carry);//进行递归，相加  
8. }  

简化一下：

[cpp] view plain copy

1. int Add(int a,int b)  
2. {  
3.     return b ? Add(a^b,(a&b)<<1) : a;  
4.     /*if(b) 
5.         return Add(a^b,(a&b)<<1); 
6.     else 
7.         return a;*/  
8. }  

上面的思路就是先不计进位相加，然后再与进位相加，随着递归，进位会变为0，递归结束。 

非递归的版本如下：

[cpp] view plain copy

1. int Add(int a, int b)  
2. {  
3.     int ans;  
4.     while(b)  
5.     {   //直到没有进位  
6.         ans = a^b;        //不带进位加法  
7.         b = ((a&b)<<1);   //进位  
8.         a = ans;  
9.     }  
10.     return a;  
11. }   

减法运算：

[cpp] view plain copy

1. //这个和加法一样了，首先取减数的补码，然后相加。  
2. int negtive(int a)   //取补码  
3. {  
4.     return Add(~a, 1);  
5. }  
6. int Sub(int a, int b)  
7. {  
8.     return Add(a, negtive(b));  
9. }   

正数乘法运算：

[cpp] view plain copy

1. //正数乘法运算  
2. int Pos_Multiply(int a,int b)  
3. {  
4.     int ans = 0;  
5.     while(b)  
6.     {  
7.         if(b&1)  
8.             ans = Add(ans, a);  
9.         a = (a<<1);  
10.         b = (b>>1);  
11.     }  
12.     return ans;  
13. }  

整数除法（正整数）

[cpp] view plain copy

1. //除法就是由乘法的过程逆推，依次减掉（如果x够减的）y^(2^31),y^(2^30),...y^8,y^4,y^2,y^1。减掉相应数量的y就在结果加上相应的数量。  
2. int Pos_Div(int x,int y)  
3. {  
4.     int ans=0;  
5.     for(int i=31;i>=0;i--)  
6.     {  
7.         //比较x是否大于y的(1<<i)次方，避免将x与(y<<i)比较，因为不确定y的(1<<i)次方是否溢出  
8.         if((x>>i)>=y)  
9.         {  
10.             ans+=(1<<i);  
11.             x-=(y<<i);  
12.         }  
13.     }  
14.     return ans;  
15. }  

完整的实现：

[cpp] view plain copy

1. // 加减乘除位运算   
2. // 程序中实现了比较大小、加减乘除运算。所有运算都用位操作实现   
3. // 在实现除法运算时，用了从高位到低位的减法   
4. // 具体如下，算法也比较简单，所以没有作注释  
5. #include<iostream>  
6. #include<cstdio>  
7. using namespace std;  
8.   
9. int Add(int a, int b)  
10. {  
11.     int ans;  
12.     while(b)  
13.     {  //直到没有进位  
14.         ans = a^b;        //不带进位加法  
15.         b = ((a&b)<<1);   //进位  
16.         a = ans;  
17.     }  
18.     return a;  
19. }  
20.   
21. //这个和加法一样了，首先取减数的补码，然后相加。  
22. int negtive(int a)   //取补码  
23. {  
24.     return Add(~a, 1);  
25. }  
26. int Sub(int a, int b)  
27. {  
28.     return Add(a, negtive(b));  
29. }  
30.   
31. // 判断正负   
32. int ispos( int a )   
33. { //正  
34.     return (a&0xFFFF) && !(a&0x8000);  
35. }  
36. int isneg( int a )   
37. { //负  
38.     return a&0x8000;  
39. }  
40. int iszero( int a )  
41. { //0  
42.     return !(a&0xFFFF);  
43. }  
44.   
45. //正数乘法运算  
46. int Pos_Multiply(int a,int b)  
47. {  
48.     int ans = 0;  
49.     while(b)  
50.     {  
51.         if(b&1)  
52.             ans = Add(ans, a);  
53.         a = (a<<1);  
54.         b = (b>>1);  
55.     }  
56.     return ans;  
57. }  
58.   
59. //乘法运算  
60. int Multiply(int a,int b)  
61. {  
62.     if( iszero(a) || iszero(b) )  
63.         return 0;  
64.     if( ispos(a) && ispos(b) )  
65.         return Pos_Multiply(a, b);  
66.     if( isneg(a) )  
67.     {  
68.         if( isneg(b) )  
69.         {  
70.             return Pos_Multiply( negtive(a), negtive(b) );  
71.         }  
72.         return negtive( Pos_Multiply( negtive(a), b ) );  
73.     }  
74.     return negtive( Pos_Multiply(a, negtive(b)) );  
75. }  
76.   
77. //除法就是由乘法的过程逆推，依次减掉（如果x够减的）y^(2^31),y^(2^30),...y^8,y^4,y^2,y^1。减掉相应数量的y就在结果加上相应的数量。  
78. int Pos_Div(int x,int y)  
79. {  
80.     int ans=0;  
81.     for(int i=31;i>=0;i--)  
82.     {  
83.         //比较x是否大于y的(1<<i)次方，避免将x与(y<<i)比较，因为不确定y的(1<<i)次方是否溢出  
84.         if((x>>i)>=y)  
85.         {  
86.             ans+=(1<<i);  
87.             x-=(y<<i);  
88.         }  
89.     }  
90.     return ans;  
91. }  
92.   
93. //除法运算  
94. int MyDiv( int a, int b )  
95. {  
96.     if( iszero(b) )  
97.     {  
98.         cout << "Error" << endl;  
99.         exit(1);  
100.     }  
101.     if( iszero(a) )  
102.         return 0;  
103.     if( ispos(a) )  
104.     {  
105.         if( ispos(b) )  
106.             return Pos_Div(a, b);  
107.         return negtive( Pos_Div( a, negtive(b)) );  
108.     }  
109.     if( ispos(b) )  
110.         return negtive( Pos_Div( negtive(a), b ) );  
111.     return Pos_Div( negtive(a), negtive(b) );  
112. }   
113.   
114.   
115. // 比较两个正数的大小（非负也可）   
116. int isbig_pos( int a, int b )   
117. {  //a>b>0  
118.     int c = 1;  
119.     b = (a^b);  
120.     if( iszero(b) )  
121.         return 0;  
122.     while( b >>= 1 )  
123.     {  
124.         c <<= 1;  
125.     }  
126.     return (c&a);  
127. }   
128.   
129. // 比较两个数的大小   
130. int isbig( int a, int b )   
131. { //a>b  
132.     if( isneg(a) )  
133.     {  
134.         if( isneg(b) )  
135.         {  
136.             return isbig_pos( negtive(b), negtive(a) );  
137.         }  
138.         return 0;  
139.     }  
140.     if( isneg(b) )  
141.         return 1;  
142.     return isbig_pos(a, b);  
143. }  

扩展：在不使用*、/、+、-、%操作符的情况下，如何求一个数的1/3？（用C语言实现）
使用位操作符并实现“+”操作

[cpp] view plain copy

1. // 替换加法运算符  
2. int add(int x , int y)  
3. {  
4.     int res;  
5.     while(y)       // 直到没有进位  http://blog.csdn.net/ojshilu/article/details/11179911
6.     {  
7.         res = x^y;       // 不带进位的加法  
8.         y = ((x&y)<<1);  // 进位  
9.         x = res;  
10.     }  
11.     return x;  
12. }  
13.   
14. int divideby3(int num)  
15. {  
16.     int sum = 0;  
17.     while(num > 3)  
18.     {  
19.         sum = add(num>>2 , sum);  
20.         num = add(num>>2 , num&3);  
21.     }  
22.     if(num == 3)  
23.         sum = add(sum , 1);  
24.     return sum;  
25. }  

原理：n = 4 * a + b; n / 3 = a + (a + b) / 3; 然后 sum += a, n = a + b 并迭代; 当 a == 0 (n < 4)时，sum += floor(n / 3); i.e. 1, if n == 3, else 0

本文转载：http://blog.csdn.net/ojshilu/article/details/11179911

　　　　　http://blog.csdn.net/hackbuteer1/article/details/7390093