求两整数相除_29.两数相除

给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。返回被除数 dividend 除以除数 divisor 得到的商。

示例1：

输入: dividend = 10, divisor = 3
输出: 3

示例2：

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

说明：

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

思路：

这道题看起来似乎很简单，实则到处都是坑，最直接的思路就是在dividend和divisor都为正数的前提下，循环用被除数dividend减除数divisor，减法进行的次数则为最后除法所得的商。因此，需要做一些预处理：1）将dividend和divisor转化为正数来处理；2）c++中int整型范围有限，需要转化为long型来处理，那么初步代码如下：

class Solution {
public:
    int divide(int dividend, int divisor) {
        if(dividend==0) return 0;
        bool flag = true;
        long res = 0;
        if((dividend > 0 && divisor < 0) || (dividend < 0 && divisor > 0)){
            flag = false;
        }
        long tmpDividend = (long)dividend;
        long tmpDivisor = (long)divisor;
        if(tmpDividend < 0){
            tmpDividend = -tmpDividend;
        }
        if(tmpDivisor < 0){
            tmpDivisor = -tmpDivisor;
        }
        while(tmpDividend >= tmpDivisor){
            tmpDividend -= tmpDivisor;
            res += 1;
        }
        if(flag){
            if(res > INT_MAX){
                return INT_MAX;
            }else{
                return (int)res;
            }
        }else{
            if(-res < INT_MIN){
                return INT_MIN;
            }else{
                return (int)(-res);
            }
        }
    }
};

但是很遗憾，OJ给的结果是超时：

分析上面算法的时间复杂度可知，当dividend非常大、而divisor非常小时（比如下图给出的test case），那while循环中需要进行减法的次数将会非常大，时间复杂度为O(dividend)，所以有没有什么办法可以减小耗时呢？分析可知，循环中每次减的数都是divisor，那是否可以提高减法的效率呢？比如成倍扩大divisor，同时成倍增加减法次数k，代码如下：

class Solution {
public:
    int divide(int dividend, int divisor) {
        if(dividend==0) return 0;
        bool flag = true;
        long res = 0;
        if((dividend > 0 && divisor < 0) || (dividend < 0 && divisor > 0)){
            flag = false;
        }
        long tmpDividend = (long)dividend;
        long tmpDivisor = (long)divisor;
        if(tmpDividend < 0){
            tmpDividend = -tmpDividend;
        }
        if(tmpDivisor < 0){
            tmpDivisor = -tmpDivisor;
        }
        while(tmpDividend >= tmpDivisor){
            long k = 1;
            long tmp = tmpDivisor;
            while(tmpDividend >= tmp){
                tmpDividend -= tmp;
                res += k;
                
                k += k;
                tmp += tmp; //扩大1倍
            }
        }
        if(flag){
            if(res > INT_MAX){
                return INT_MAX;
            }else{
                return (int)res;
            }
        }else{
            if(-res < INT_MIN){
                return INT_MIN;
            }else{
                return (int)(-res);
            }
        }
    }
};

OJ险过，很显然这个算法的时间复杂度和空间复杂度依然不太优秀，但是题解区的一些解法思路让我累觉不爱，有些实在是没看懂，姑且按这个易懂的思路来吧。