转载地址：https://ych0112xzz.github.io/2016/10/27/OperationwithBits/
位运算实现整数加法
方法
- x^y //执行加法，不考虑进位。
- (x&y)<<1 //进位操作
解释
在这里我们先用1位数的加法来进行，在不考虑进位的基础上，如下
|
1
2
3
4
|
1 + 1 = 0
1 + 0 = 1
0 + 1 = 1
0 + 0 = 0
|
很明显这几个表达式可以用位运算的异或（“^”）操作来代替，如下
|
1
2
3
4
|
1 ^ 1 = 0
1 ^ 0 = 1
0 ^ 1 = 1
0 ^ 0 = 0
|
这样我们就完成了简单的一位数加法，那么要进行二位的加法，这个方法可行不可行呢？肯定是不行的，矛盾就在于，如何去获取进位？要获取进位我们可以如下思考:
|
1
2
3
4
|
0 + 0 = 0
1 + 0 = 0
0 + 1 = 0
1 + 1 = 1
|
换个角度看就是这样
|
1
2
3
4
|
0 & 0 = 不进位
1 & 0 = 不进位
0 & 1 = 不进位
1 & 1 = 进位
|
正好，在位运算中，我们用”<<”表示向左移动一位，也就是“进位”。那么我们就可以得到如下的表达式
- 进位可以用如下表示:
(x&y)<<1;
到这里，我们基本上拥有了这样两个表达式
- x^y //执行加法
- (x&y)<<1 //进位操作
举例
我们来做个2位数的加法
- 本来的算法
11+01 = 100 - 用推算的表达式计算
1211 ^ 01 = 10(11 & 01) << 1 = 10
到这里 我们用普通的加法去运算这两个数的时候就可以得到 10 + 10 = 100,但是我们不需要加法，所以要想别的方法，如果让两个数再按刚才的算法计算一次呢。
|
1
2
|
10 ^ 10 = 00
(10 & 10) << 1 = 100
|
到这里基本上就得出结论了，其实后面的那个 “00” 已经不用再去计算了，因为第一个表达式就已经算出了结果。继续推理可以得出三位数的加法只需重复的计算三次得到第一个表达式的值就是计算出来的结果。
java代码
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
<!-- 递归实现 -->
public int add(int x,int y){
if(y==
0) {
return x; }
//没有进位时完成运算
int sum,carry;
sum=x^y;
carry=(x&y)<<
1;
return Add(sum,carry);
//递归相加
}
<!-- 非递归实现 -->
public int Add(int a, int b) {
/*return (b == 0) ? a : add(a ^ b, (a & b) << 1);*/
while(b!=
0){
int sum;
sum = a ^ b;
b = (a & b) <<
1;
a = sum;
}
return a;
}
|
总结
计算机本质是二进制运算，乘法等问题解决的关键是如何用位运算实现加法。觉得原文叙述不够精确，现总结如下。
- 定理1：设a，b为两个二进制数，则
a+b = a^b + (a&b)<<1。
证明：a^b是不考虑进位时加法结果。当二进制位同时为1时，才有进位，因此(a&b)<<1是进位产生的值，称为进位补偿。将两者相加便是完整加法结果。 - 定理2：使用定理1可以实现只用位运算进行加法运算。
证明：利用定理1中的等式不停对自身进行迭代。每迭代一次，进位补偿右边就多一位0，因此最多需要加数二进制位长度次迭代，进位补偿就变为0，这时运算结束。
位运算实现减法
减法可以转化成加法：a - b = a + (-b) = a + (~b + 1)。
|
1
2
3
|
int sub(int a, int b){
return add(a, add(~b,
1));
}
|
位运算实现乘法
先看一个乘法运算：1011*1010
|
1
2
3
4
5
6
7
|
1011
* 1010
--------
10110 (1011<<1,相当于乘以0010)
1011000 (1011<<3,相当于乘以1000)
--------
1101110
|
因此乘法可以通过系列的移位和加法实现。
|
1
2
3
4
5
6
7
8
9
10
11
|
int mul(int a,int b){
int ans =
0;
while(b!=
0){
if((b&
1)!=
0) {
ans = add(ans, a);
}
a <<=
1;
b >>=
1;
}
return ans;
}
|
乘除法运算需要考虑符号问题，我们将它作为正数考虑，先来看几个辅助函数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
<!--获取符号 -->
int getsign(int i){
return (i>>
31);
}
//获取相反数；
int getNegtive(int i){
return getSum(~i,
1);
}
//获取一个数的正数形式
int getPositive(int i){
if((i >>
31)!=
0){
//不能用>0判断，负数移位后为1，因其高位补零。
return getNegtive(i);
}
else{
return i;
}
}
|
同时，我们需要考虑临界值的溢出问题。因此，完整的乘法代码是
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
int mul(int a, int b) {
boolean flag =
false;
if (getSign(a) == getSign(b)) {
flag =
true;
}
int ans =
0;
if (a == Integer.MIN_VALUE && b == Integer.MIN_VALUE) {
return
1;
}
if (b == Integer.MIN_VALUE) {
return
0;
}
if(a==Integer.MIN_VALUE){
if(b==-
1){
return Integer.MAX_VALUE;
}
ans =
1;
a = add(a,getPositive(b));
}
a = getPositive(a);
b = getPositive(b);
while (b !=
0) {
if ((b &
1) !=
0) {
ans = add(ans, a);
// System.out.println(a+"\t"+b+"\t"+ans);
}
a <<=
1;
b >>=
1;
}
return flag ==
true ? ans : getNegtive(ans);
}
|
位运算实现除法
除法就是由乘法的过程逆推，依次减掉（如果a够减的）b ^ (2 ^ 31), b ^ (2 ^ 30), …b ^ 8, b ^ 4, b ^ 2, b ^ 1 。减掉相应数量的b就在结果加上相应的数量。
以下为10110000 / 1010的部分步骤：
|
1
2
3
4
5
|
10110000 / 1010
10110100
-10100000 (1010<<4)
10100
- 10100 (1010<<1)
|
考虑符号问题，完整代码是
int div(int a, int b) {
boolean flag = false;
if (getSign(a) == getSign(b)) {
flag = true;
}
a = getPositive(a);
b = getPositive(b);
int ans = 0;
for (int i = 31; i >= 0; i--) {
if (b <= (a >> i)) {
ans = add(ans, 1 << i);
a = sub(a, b << i);
}
}
return flag == true ? ans : getNegtive(ans);
}