29. 两数相除

一、题目

给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。

返回被除数 dividend 除以除数 divisor 得到的商。

示例 1:

输入: dividend = 10, divisor = 3
输出: 3
示例 2:

输入: dividend = 7, divisor = -3
输出: -2
说明:

被除数和除数均为 32 位有符号整数。
除数不为 0。
假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−2^31, 2^31 − 1]。本题中，如果除法结果溢出，则返回 2^31 − 1。

二、解答

2.1方法一：列竖式算除法(86+%，推荐方法2)

2.1.1思路

让我们先回顾一下小学时，怎么通过列竖式的方法计算两个整数的除法，以 45/2 为例：

十进制除法

仔细观察不难发现，这种算法是把除法化归成移位和减法两种运算方法。对于 10 进制数，移位运算就是乘（左移）除（右移）10，而我们都知道计算机中的移位运算是乘（左移）除（右移）2，因为计算机是通过二进制的方法存储数的。这样，类比十进制，二进制的除法（仍以 45/2 为例）可以写作（注意，这里我们并没有用到乘除法）

二进制除法

2.1.2 实现

   /**
     * 防止Math.abs后溢出，转换成long运算
     * @param dividend
     * @param divisor
     * @return
     */
  public int divide(int dividend, int divisor) {
        boolean negative = (dividend > 0) ^ (divisor > 0);

        long divisor1 = Math.abs((long)divisor);
        long dividend1 = Math.abs((long)dividend);

        int count = 0;
        //计算最大移位;把除数不断左移，直到它大于被除数
        while (dividend1 >= divisor1){
            count++;
            divisor1 <<= 1;
        }

        long result = 0;

        while (count > 0){
            count--;
            divisor1 >>= 1;

            if(divisor1 <= dividend1){
                //这里的移位运算是把二进制（第count+1位上的1）转换为十进制
                //Math.abs((long)(1 << count))为了兼容(1<<31)的时候返回负数
                result += Math.abs((long)(1 << count));
                dividend1 -= divisor1;
            }
        }

        result = negative ? -result : result;
        return (int)(-(1<<31) <= result && result <= (1<<31)-1 ? result : (1<<31)-1);
    }

2.2方法二：除数倍增+迭代循环(推荐，98+%)

2.2.1思路

除数倍增,商的计数器count也倍增,直到除数刚好比被除数小,就用被除数减去除数,更新数值,再进行下一次循环,直到被除数绝对值小于除数绝对值,其间需要考虑除数溢出,count溢出的情况。

2.2.2 实现

/**
     * 考虑到负数范围比正数范围大，所以都改成负数，避免result溢出的处理
     * 采用算法除数倍增（divisor + divisor）+ 迭代
     * divisor + divisor可以采用移位<<1表示倍增
     * @param dividend
     * @param divisor
     * @return
     */
    public int divide(int dividend, int divisor) {
        //兼容特殊情况
        if (dividend == Integer.MIN_VALUE && divisor == -1)
            return Integer.MAX_VALUE;

        // 1 表示正数，-1表示负数；
        boolean negative = (dividend > 0) ^ (divisor > 0);

        dividend = dividend > 0 ? -dividend : dividend;
        divisor = divisor > 0 ? -divisor : divisor;

        int result = 0, tmpd, k;
        while (dividend <= divisor) {
            tmpd = divisor;
            k = 1;
            //(tmpd << 1)< 0兼容溢出
            while (dividend <= (tmpd << 1) && (tmpd << 1) < 0) {
                tmpd <<= 1;
                k <<= 1;
            }
            result += k;
            dividend -= tmpd;
        }
        return !negative ? result : -result;
    }