力扣题目：两数相除

两数相除

题目描述：

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

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

整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2

思路：

我们要计算两个数相除的商，但是又不能使用乘除法和取模运算，那么就只能使用加法、减法或者位运算了。

我们知道，可以使用加法模拟乘法，使用减法模拟除法，位运算可以模拟乘2或者除2的运算；

在模拟之前我们还需要考虑几点特殊的问题：

• 整数限定的范围是32位，那么其取值范围就是 -2^31 — 2^31-1;

• 因为负数的范围比较大，当商为2^31时，会发生越界，所以我们可以通过同号为正，异号为负的方法确定结果的正负，然后将所有的正数转化为负数来求解。

• 正值运算还好说，遇到负值运算，如果被除数是-2^31 ，除数是-1，直接相除的话会产生越界的结果；所以要注意几个特殊值：

  • 当divisor == INT_MIN时 ：
    • 如果INT_MIN == dividend ，直接返回 1;
    • 如果是其他值，直接返回0；
  • 当dividend == 0时，不管divisor是多少，都直接返回0；
  • 当dividend == INT_MIN时：
    • 如果divisor == -1，直接返回INT_MAX;
    • divisor == 1 ，我们可以直接返回INT_MIN;

• 除此之外，如果我们每次循环都只减一次divisor那么遇到特殊情况，时间复杂度将会非常高，例如dividend = 214836748，divisor = 3的情况，就需要减很多次。那么就需要采用一种方法去降低时间复杂度，我这里用的是倍增法：

  • 每次增加一倍的方法去减，时间复杂度就变成了log dividend；

    //这里的A和B都是负数，比较方法和正数正好相反
    int helper(int a,int b)
    {
        //当被除数不够除时的操作
        if(a >= b) return a > b ? 0 : 1;
        
        int count = 1;//经过上面的判断，dividend至少可以减一次divisor
        int tb = b;//当做减数
        int res = 0; // 用来存储结果
        
        while(a < tb)
        {
            //被除数每减一次除数，就要计数一次
            a -= tb;
            count += 1;
            //使用倍增法降低时间复杂度
            tb += tb;
            count += count;
        }
        res = count;
        return res + helper(a,b);
    }
    

    算法是写完了，但是上面的算法在我验证的时候出了点儿错误，那就是当除数大于-2^31/2的时候，无疑出现这种情况，我们的结果就是1，但是算法没法直接得出判断，他还是会执行tb+=tb这一步，如果此时我们使用倍增法，那么就会产生overflow的错误。

    如何解决呢？再写一个特例？不不不，我们的特例已经足够多了，我们只需要在执行tb += tb之前再来一次判断即可，因为要执行tb += tb 的目的是，为了降低时间复杂度，那么只需要判断a还能否再减tb,如果可以，在执行下面的条件，如果不行就跳出，如此即可完美解决问题；

    //完整算法
    class solution{
        public:int divide(int dividend,int divisor)
        {
            if(dividend == 0) return 0;
            
            if(dividend == INT_MIN)
            {
                if(divisor == -1) return INT_MAX;
                if(divisor == 1)return INT_MIN;
            }
            
            if(divisor == INT_MIN)
            {
                if(dividend == INT_MIN) return 1;
                else return 0;
            }
            
            int sign = -1;
            if((dividend  >0 &&divisor > 0) || (dividend <0 && divisor < 0))
            {
                sign = 1;
            }
            
            dividend = dividend > 0 ? -dividend : dividend;
            divisor = divisor > 0 ? -divisor : divisor;
            
            int ans = helper(dividend,divisor);
            return sign > 0 ? ans : -ans;
        }
        
        int helper(int a , int b)
        {
            if(a >= b) return a > b ? 0 : 1;
            
            int count = 1;
            int res = 0;
            int tb = b;
            while(a < tb)
            {
                a -= tb;
                count += 1;
                if(a < tb)
                {
                    tb += tb;
                    count += count;
                }
            }
            
            res = count;
            return res + helper(a,b);
        }
    }
    

下面是官方给出的解法：

使用二分查找法：

思路：由于我们只能使用 3232 位整数，因此二分查找中会有很多细节。

首先，二分查找的下界为 11，上界为 2^31−1。唯一可能出现的答案为 2^31的情况已经被我们在「前言」部分进行了特殊处理，因此答案的最大值为 2^31−1。如果二分查找失败，那么答案一定为 0。

在实现「快速乘」时，我们需要使用加法运算，然而较大的 ZZ 也会导致加法运算溢出。例如我们要判断 A+B 是否小于 C 时（其中 A,B,C 均为负数），A+B 可能会产生溢出，因此我们必须将判断改为 A<C−B 是否成立。由于任意两个负数的差一定在 [−2^31,231−1][−2^31+1,231−1] 范围内，这样就不会产生溢出。

class Solution {
public:
    int divide(int dividend, int divisor) {
        // 考虑被除数为最小值的情况
        if (dividend == INT_MIN) 
        {
            if (divisor == 1) return INT_MIN;
           
            if (divisor == -1) return INT_MAX;
        }
        // 考虑除数为最小值的情况
        if (divisor == INT_MIN) return dividend == INT_MIN ? 1 : 0;
        
        // 考虑被除数为 0 的情况
        if (dividend == 0) {
            return 0;
        }
        
        // 一般情况，使用二分查找
        // 将所有的正数取相反数，这样就只需要考虑一种情况
        bool rev = false;
        if (dividend > 0) 
        {
            dividend = -dividend;
            rev = !rev;
        }
        if (divisor > 0) 
        {
            divisor = -divisor;
            rev = !rev;
        }

        // 快速乘
        auto quickAdd = [](int y, int z, int x) 
        {
            // x 和 y 是负数，z 是正数
            // 需要判断 z * y >= x 是否成立
            int result = 0, add = y;
            while (z) {
                if (z & 1) {
                    // 需要保证 result + add >= x
                    if (result < x - add) {
                        return false;
                    }
                    result += add;
                }
                if (z != 1) {
                    // 需要保证 add + add >= x
                    if (add < x - add) {
                        return false;
                    }
                    add += add;
                }
                // 不能使用除法
                z >>= 1;
            }
            return true;
        };
        
        int left = 1, right = INT_MAX, ans = 0;
        while (left <= right) {
            // 注意溢出，并且不能使用除法
            int mid = left + ((right - left) >> 1);
            bool check = quickAdd(divisor, mid, dividend);
            if (check) {
                ans = mid;
                // 注意溢出
                if (mid == INT_MAX) {
                    break;
                }
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
        }

        return rev ? -ans : ans;
    }
};