个人记录-LeetCode 29. Divide Two Integers

最新推荐文章于 2024-04-23 07:08:59 发布

原创最新推荐文章于 2024-04-23 07:08:59 发布 · 752 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 同时被 2 个专栏收录

108 篇文章

订阅专栏

LeetCode练习记录

108 篇文章

订阅专栏

本文介绍两种不使用乘除及取余操作实现整数除法的方法：一种基于十进制加法，但效率较低；另一种利用二进制位移提高效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

问题：
Divide two integers without using multiplication, division and mod operator.

If it is overflow, return MAX_INT.

代码示例：
1、十进制思维

将乘除法变为加法运算。
该方法可行，但 Time Limit Exceeded。

public class Solution {
    public int divide(int dividend, int divisor) {
        if (divisor == 0) {
            return Integer.MAX_VALUE;
        }

        //决定结果是否取反
        boolean negative = false;

        //决定加法的前进方向
        boolean minusWay = false;

        if (dividend > 0 && divisor < 0) {
            divisor = -divisor;
            negative = true;
        } else if (dividend < 0 && divisor > 0) {
            divisor = -divisor;
            negative = true;
            minusWay = true;
        } else if (dividend < 0 && divisor < 0) {
            minusWay = true;
        }

        long result = 0;
        long sum = 0;
        if (minusWay) {
            while (sum >= dividend) {
                sum += divisor;
                ++result;
            }
        } else {
            while (sum <= dividend) {
                sum += divisor;
                ++result;
            }
        }

        --result;

        if (negative) {
            result = -result;
        }
        System.out.println(result);

        return result > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int)result;
    }
}

2、二进制思维

这里最主要的技巧在于使用移位代替了乘法，既满足题目要求，又提高了速度。
根本的原理是：计算机中的任何数都可以用二进制表示。

public class Solution {
    public int divide(int dividend, int divisor) {
        if (divisor == 0) {
            return Integer.MAX_VALUE;
        } else if (divisor == Integer.MIN_VALUE) {
            if (dividend == Integer.MIN_VALUE) {
                return 1;
            } else {
                return 0;
            }
        }

        boolean negative = false;

        long newDividend = dividend;
        long newDivisor = divisor;

        if (dividend > 0 && divisor < 0) {
            newDivisor = -divisor;
            negative = true;
        } else if (dividend < 0) {
            if (dividend == Integer.MIN_VALUE) {
                newDividend = Integer.MAX_VALUE;
                newDividend += 1;
            } else {
                newDividend = -dividend;
            }

            if (divisor > 0) {
                negative = true;
            } else {
                newDivisor = -divisor;
            }
        }

        //迭代得到结果
        long result = getResult(newDividend, newDivisor);
        if (negative) {
            result = -result;
        }

        return result > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int)result;
    }

    private long getResult(long dividend, long divisor) {
        if (dividend < divisor) {
            return 0;
        }

        long result = 1;
        long sum = divisor;
        //移位找到最大的可被整除的部分
        while (sum <= dividend) {
            sum = sum << 1;
            result = result << 1;
        }

        result = result >> 1;
        sum = sum >> 1;
        //下次迭代时，只需要找到剩余的最大可被整除的部分
        result = result + getResult(dividend - sum, divisor);

        return result;
    }
}