leetcode-两数相除

最新推荐文章于 2020-10-20 11:32:08 发布

原创最新推荐文章于 2020-10-20 11:32:08 发布 · 334 阅读

0 ·

CC 4.0 BY-SA版权

本文探讨了如何处理大数除法问题，通过暴力法、位运算和倍数寻找策略，介绍了三种不同的解决方案，包括异或判断、长整型处理和利用位移技巧，以提高计算效率并避开溢出问题。

两数相除

在这里插入图片描述这道题初看很简单，将除法变为减法即可，但是其实要考虑很多边界条件！而其要是被除数的值非常大而除数的值非常小，那么要减到天荒地老！必定会超时：

暴力法

class Solution {
public:
    int divide(int dividend, int divisor) {
        bool flag = true;
        //用异或来判断相除是负数还是正数
        if((dividend^divisor)<0)
            flag = false;
        
        //因为32位整数的取值范围：-2,147,483,648～2,147,483,647
        //而INT_MIN的绝对值会溢出，因此不如dividend和divisor都换负数，而不是都取绝对值 
        if(dividend>0)
            dividend = -dividend;
        if(divisor>0)
            divisor = -divisor;
        
        if(dividend>divisor)
            return 0;
        if(dividend == divisor)
            return flag?1:-1;
        if(divisor == -1){
            if(dividend == INT_MIN && flag)
                return INT_MAX;
            return flag?-dividend:dividend;
        }
        int res = 0;
        while(dividend<=0){
            dividend -= divisor;
            res++;
        }
        res--;
        return flag?res:-res;
        

    }
};

为了不再一个一个的减，我们可以直接去找到一个除数的倍数，让除数乘以倍数小于被除数，然后和被除数相减，不断循环直到被除数小于除数！那么既然不准使用除法，也不能使用乘法，用什么方法来找倍数呢？可以使用位运算的方式！将一个数左移n位其实相当于这个数乘以2的n次方！那么我们只需要每次都找到使除数乘以倍数小于被除数的那个n即可！
但是仍然存在问题，因为我们是从n=31位往后去找合适的n，那么不可以用int类型的数据去右移多位，会出现溢出，因此必须将dividend和divisor转换为long类型！

位运算法

class Solution {
public:
    int divide(int dividend, int divisor) {
        bool flag = true;
        if((dividend^divisor)<0)
            flag = false;
        
        if(dividend == INT_MIN && divisor == -1)
            return INT_MAX;
        if(divisor == 1)
            return dividend;
        
        long dividend_l = abs((long)dividend);
        long divisor_l = abs((long)divisor);

        if(dividend_l<divisor_l)
            return 0;
        
        int res = 0;
        for(int i=31;i>=0;i--){
            if(dividend_l>=(divisor_l<<i)){
                dividend_l -= (divisor_l<<i);
                res += (1<<i);
            }
        }

        return flag?res:(-res);
        

    }
};

其实这题我觉得核心思想还是要避免使用浪费时间的单次运算，最好每次都一步到位; 这题还有一个减法的思路是，不是每次减去本身，而是每次将divisor翻倍再去减，这样也可以提升效率！但是实现起来会麻烦一些，而且这道题的边界条件处理太恶心了。

完全符合题目条件的解法，不使用long，不使用位移，而是用divisor+divisor来获取加倍迭代，并且将正数全部变为负数来计算，避免了溢出，但是处理起来很费劲：

class Solution {
public:
    int divide(int dividend, int divisor) {
        bool flag = true;
        if((dividend^divisor)<0)
            flag = false;
        
        if(dividend == INT_MIN && divisor == -1)
            return INT_MAX;
        
        if(divisor == 1)
            return dividend;
        if(dividend>0) dividend = -dividend;
        if(divisor>0) divisor = -divisor;
        int tmp = 0;
        int count = 0;
        
        while(dividend<=divisor){
            int res = 1;
            int divisor_tmp = divisor;
            while(true){
                tmp = divisor_tmp;
                if(INT_MIN - divisor_tmp > divisor_tmp){
                    tmp = 0;
                    break;
                }
                divisor_tmp += divisor_tmp;
                if(dividend-divisor_tmp>0)
                    break;
                res += res;
            }
            
   
            count += res;
            divisor_tmp -= tmp;
            dividend -= divisor_tmp;     
        }

        return flag?count:-count;
    

    }
};