Leetcode 29. Divide Two Integers--两个32位整数相除，小数位截断，不能使用乘法、除法、取模运算

版权声明：本文为博主原创文章，转载请说明出处 https://blog.csdn.net/u010002184/article/details/86418315

Given two integers dividend and divisor, divide two integers without using multiplication, division and mod operator.

Return the quotient after dividing dividend by divisor.

The integer division should truncate toward zero.

Example 1:

Input: dividend = 10, divisor = 3
Output: 3

Example 2:

Input: dividend = 7, divisor = -3
Output: -2

Note:

• Both dividend and divisor will be 32-bit signed integers.
• The divisor will never be 0.
• Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−231,  231 − 1]. For the purpose of this problem, assume that your function returns 231 − 1 when the division result overflows.

方法1：

public class Leetcode_29_DivideTwoIntegers {

    public static void main(String[] args) {
        Leetcode_29_DivideTwoIntegers leetcode_29_divideTwoIntegers = new Leetcode_29_DivideTwoIntegers();
//        System.out.println(leetcode_29_divideTwoIntegers.divide(15, 3));//5
//        System.out.println(leetcode_29_divideTwoIntegers.divide(16, -3));//-5
//        System.out.println(leetcode_29_divideTwoIntegers.divide(16, 2));//8
        System.out.println(leetcode_29_divideTwoIntegers.divide(2147483647, 2));
    }

    /**
     * Runtime: 30 ms, faster than 68.57%
     *
     * @param dividend
     * @param divisor
     * @return
     */
    public int divide(int dividend, int divisor) {
        if (divisor == 1) {
            return dividend;
        }
        if (divisor == -1 && dividend == Integer.MIN_VALUE) {
            return Integer.MAX_VALUE;
        }
        if (divisor == -1) {
            return -dividend;
        }
        //需要转化为long，不然后面会因为int溢出导致wrong answer
        long dividendL = dividend;
        long divisorL = divisor;

        //c/b=a，c是被除数，b是除数，a是商；如果被除数与除数都是正数或都是负数，则商是正数；反之商是负数
        int sign = (dividendL > 0 ^ divisorL > 0) ? -1 : 1;
        if (dividendL < 0) {
            dividendL = Math.abs(dividendL);
        }
        if (divisorL < 0) {
            divisorL = Math.abs(divisorL);
        }
        int quotient = implDivide(dividendL, divisorL);
        return sign == 1 ? quotient : -quotient;
    }

    public int implDivide(long dividend, long divisor) {
        int pow2 = 1;
        long multi = divisor;
        while (dividend >= divisor) {
            while (multi < dividend) {
                multi = multi << 1;
                pow2 = pow2 << 1;
            }
            if (multi == dividend) {
                return pow2;
            }
            multi = multi >> 1;
            pow2 = pow2 >> 1;
            dividend = dividend - multi;
            return pow2 + implDivide(dividend, divisor);
        }
        return 0;
    }
}

方法2：Wring Answer

    /**
     * Wrong Answer
     *
     * @param dividend
     * @param divisor
     * @return
     */
    public int divide(int dividend, int divisor) {
        if (dividend == 0) {
            return 0;
        }

        if (divisor == Integer.MIN_VALUE) {
            if (dividend == Integer.MIN_VALUE) {
                return 1;
            } else {
                return 0;
            }
        }

        if (divisor == 1) {
            return dividend;
        }
        if (divisor == -1 && dividend == Integer.MIN_VALUE) {
            return Integer.MAX_VALUE;
        }
        if (divisor == -1) {
            return -dividend;
        }

        int quotient = implDivide(dividend, divisor);
        return quotient;
    }

    public int implDivide(int dividend, int divisor) {
        if (dividend > 0) {
            return implDividendPositive(dividend, divisor);
        } else {
        }
        return implDividendNegative(dividend, divisor);
    }

    public int implDividendNegative(int dividend, int divisor) {
        int pow2 = (dividend > 0 ^ divisor > 0) ? -1 : 1;
        int multi = divisor * pow2;
        divisor = divisor * pow2;
        while (dividend <= divisor) {
            while (multi > dividend) {
                multi = multi << 1;
                pow2 = pow2 << 1;
                if (multi < -Math.pow(-2, 30)) {
                    break;
                }
            }
            if (multi == dividend) {
                return pow2;
            }
            multi = multi >> 1;
            pow2 = pow2 >> 1;
            dividend = dividend - multi;
            if (pow2 > 0) {
                return pow2 + implDividendNegative(dividend, divisor);
            } else {
                return pow2 - implDividendNegative(dividend, divisor);
            }
        }
        return 0;
    }


    public int implDividendPositive(int dividend, int divisor) {
        int pow2 = (dividend > 0 ^ divisor > 0) ? -1 : 1;
        int multi = divisor * pow2;
        divisor = divisor * pow2;
        while (dividend >= divisor) {
            while (multi < dividend) {
                multi = multi << 1;
                pow2 = pow2 << 1;
                if (multi < Integer.MAX_VALUE && multi > Math.pow(2, 30) - 1) {
                    break;
                }
            }
            if (multi == dividend) {
                return pow2;
            }
            multi = multi >> 1;
            pow2 = pow2 >> 1;
            dividend = dividend - multi;
            if (pow2 > 0) {
                return pow2 + implDividendPositive(dividend, divisor);
            } else {
                return pow2 - implDividendPositive(dividend, divisor);
            }
        }
        return 0;
    }

方法3：

扫描二维码关注公众号，回复： 4904792 查看本文章