c-1:位运算:实现整数的加减乘除四则运算

首先回忆计算机组成原理学过的内容，数字在机器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

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

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


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

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


int negtive(int i)
{
    return add(~i, 1);
}
int subtraction(int a, int b) //减法运算：利用求负操作和加法操作
{
    return add(a, negtive(b));
}
问题三： 位运算实现乘法
乘法操作时即使用补码也要需要考虑符号位了，所以我要先把符号拿出来单独计算。为了方便，先引入两个工具函数，

int getsign(int i) //取一个数的符号，看是正还是负
{
    return (i>>31);
}
 
int bepositive(int i) //将一个数变为正数，如果本来就是正，则不变；如果是负，则变为相反数。注意对于-2147483648，求负会溢出。
{
    if(i>>31)
        return negtive(i);
    else
        return i;
}
做乘法的第一种思路：
很直观，就是用循环加法替代乘法。a*b，就是把a累加b次。时间复杂度为O(N)。

int multiply(int a, int b)
{
    bool flag = true;
    if(getsign(a) == getsign(b)) //积的符号判定
        flag = false;
 
    a = bepositive(a);//先把乘数和被乘数变为正数
    b = bepositive(b);
    int ans = 0;
    while(b)
    {
        ans = add(ans, a);
        b = subtraction(b, 1);
    }
 
    if(flag)
        ans = negtive(ans);
    return ans;
}
做乘法的第二种思路：
在二进制数上做乘法，如下图：



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


int multiply(int a, int b)
{
    bool flag = true;
    if(getsign(a) == getsign(b)) //积的符号判定
        flag = false;
 
    a = bepositive(a);
    b = bepositive(b);
    int ans = 0;
    while(b)
    {
        if(b&1)
            ans = add(ans, a);
        a = (a<<1); //把a错位加在积上
        b = (b>>1); //从最低位开始依次判断b的每一位
    }
 
    if(flag)
        ans = negtive(ans);
    return ans;
}
问题四： 位运算实现除法
做除法的第一种思路：
也比较直观，从被除数上减去除数，看能减多少次之后变得不够减。时间复杂度为O(N)。

int division(int a, int b)
{
    if(b==0)
        return 0;
 
    bool flag = true;
    if(getsign(a) == getsign(b)) //积的符号判定
        flag = false;
 
    a = bepositive(a);
    b = bepositive(b);
 
    int n = 0;
    a = subtraction(a, b);
    while(a>=0)
    {
        n = add(n, 1);
        a = subtraction(a, b);
    }
 
    if(flag)
        n = negtive(n);
    return n;
}
做除法的第二种思路：
第一种方法实在太慢了。减法得减的快一些，不能一个一个减，于是采用类似二分法的思路，从除数*最大倍数开始测试，如果比被除数小，则要减去。下一回让除数的倍数减少为上一次倍数的一半，这样的直到倍数为1时，就能把被除数中所有的除数减去，并得到商。时间复杂度降低到O(logN)。


int divide(int dividend, int divisor) {
    bool flag = true;
    if(getsign(dividend) == getsign(divisor)) //积的符号判定
        flag = false;
 
    unsigned int x = bepositive(dividend);
    unsigned int y = bepositive(divisor);
 
    int ans=0;
    int i=31;
    while(i>=0)
    {  
        //比较x是否大于y*(1<<i)=(y<<i)，避免直接比较，因为不确定y*(1<<i)是否溢出  
        if( (x>>i) >= y)  //如果够减
        {
            ans = add(ans, (1<<i));
            x = subtraction(x, (y<<i));
        }
        i = subtraction(i, 1);
    }
    if(flag)
        ans = negtive(ans);
    return ans;
}


注意细节：

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结构。

int add(int n, int &sum)  
{  
    n && add(n-1, sum);  
    return (sum += n);  
}  

或者

int  sum(int n)
{
    int k;
    ((1 == n)&&(k = 1)) || (k = sum(n-1) + n);
    return k;

---------------------
作者：ojshilu
来源：CSDN
原文：https://blog.csdn.net/ojshilu/article/details/11179911
版权声明：本文为博主原创文章，转载请附上博文链接！