leetcode------两数相除

题目：

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

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

说明:

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

思路：很明显，这一题不让用除法，那就只能用移位运算符来实现，就是让除数一次次的扩大，直到超过被除数

什么意思呢？：我截取的题解，之前都是10进制的数进行除法，实际上就是通过移位来实现。

比如45的二进制为101101，那么将除数10进行左移4次，达到100000，则在移位就将超过了，于是最高位就是1<<4;也就是最高位需要1<<4  这么多10的倍数，依次类推；

这里其实最烦人的就是数据溢出和被除数小于除数，因为大于0向左移位会出现2^31,但是最大也只有2^31-1,所以我刚开始将正数全转成负数，这样就不会出现数据溢出，但是这个平台上不允许负数左移，。。。，于是就再一次修改，

首先，我进行的判断是，是否被除数小于除数，从而返回0

if(被除数>0  &&  除数<0  && (-被除数>除数))    like：-15/-25
    return   0 ；
else if( 被除数<0  &&  除数>0  &&  (被除数>-除数))  like：-2/87
    return 0;
else if( 均为大于0 &&  被除数 < 除数)   like：8/98 
    return 0;
else if(均为小于0  &&  被除数 > 除数)     like: -48/-78
    return 0;

然后再来解决数据溢出问题，我首先将二者全部换成正数，当然这里有可能有一个是INT_MIN，那么就不能用这个了，于是我的办法就是首先先让被除数先减去一个除数，这样就不会出现数据溢出了

dividend代表被除数 ，divisor 代表除数
if((dividend>divisor&&均大于0)||(dividend<divisor&&均小于0))
{
      dividend-=divisor;
      res++;
}else if(   (dividend>divisor&&(-dividend<divisor)) \   like : 78/-2
            ||(dividend<divisor&&(dividend<-divisor)&&异号))  like: -78/3
{
       dividend+=divisor;
       res++;
}

接下来就是算法了：

class Solution {
public:
    int divide(int dividend, int divisor) {
        if(dividend==0) return 0;
        if (dividend == INT_MIN && divisor == -1) {
            return INT_MAX;
        }
        if (dividend == INT_MAX && divisor == 1) {
            return INT_MAX;
        }
        if (dividend == INT_MIN && divisor == 1) {
            return INT_MIN;
        }
        if(dividend == INT_MIN && divisor == INT_MAX) {
            return -1;
        }
        if(dividend == INT_MAX && divisor == INT_MIN) {
            return 0;
        }
        if (dividend == INT_MAX && divisor == INT_MAX) {
            return 1;
        }
        if (dividend == INT_MIN && divisor == INT_MIN) {
            return 1;
        }
 
        
        int sign = ((dividend > 0) ^ (divisor > 0)) ? -1 : 1;

        int s=((dividend < 0) && (divisor < 0)) ? 1 : -1;

        int res=0;

        if((dividend>divisor&&sign>0&&s<0)||(dividend<divisor&&s>0))
        {
            dividend-=divisor;
            res++;
        }else if((dividend>divisor&&(-dividend<divisor))||(dividend<divisor&&(dividend<-divisor)&&s<0))
        {
            dividend+=divisor;
            res++;
        }else if(dividend>0&&divisor<0&&(-dividend>divisor)) {
            return 0;
        }else if(dividend<0&&divisor>0&&(dividend>-divisor))  return 0;
        else if(sign>0&&s<0&&dividend<divisor)  return 0;
        else if(s>0&&dividend>divisor)  return 0;
        
        int dvs=abs(divisor);

        int dvd=abs(dividend);
        int temp=0,m=0;

        
        while (dvd >= dvs) {
            temp = dvs;
            m = 1;
            //因为我前面减去了一个除数，所以最多只需要移位30次
            for(int i=0;i<30;++i)
            {
                //这里还要判断是否溢出，只要当temp大于2^30，那么接下来就会数据溢出，
                //于是我直接跳出，并且这次的溢出也是没必要进行判断的
                if((temp >=-(INT_MIN>>1))) break;
                if(temp << 1 <= dvd) {
                    temp <<= 1;
                    m <<= 1;
                }
                else break;
            }
            dvd -= temp;
            res += m;
        }
        
        return sign * res;

        
    }
};

算法复杂度：N代表被除数，首先是外层循环，而内层最坏的情况下是，于是最坏的时间复杂度为