29. Divide Two Integers

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

If it is overflow, return MAX_INT.

比较经典的是下面这种二分查找的

比如 15/1

尝试找到1的最大倍数<=15

依次递进 分别是1,2,4,8倍 当16的时候已经不可以了 

然后15-8=7 再次尝试 1,2,4 

15-8-4…

相当于是一个棋子从起点到终点 先跨大步 如果后面步子太大超过了终点 那么再将上次的位置作为起点 从最小的步子开始 

public int divide(int dividend, int divisor) {    //Reduce the problem to positive long integer to make it easier.    //Use long to avoid integer overflow cases.    int sign = 1;    if ((dividend > 0 && divisor < 0) || (dividend < 0 && divisor > 0))        sign = -1;    long ldividend = Math.abs((long) dividend);    long ldivisor = Math.abs((long) divisor);        //Take care the edge cases.    if (ldivisor == 0) return Integer.MAX_VALUE;    if ((ldividend == 0) || (ldividend < ldivisor)) return 0;        long lans = ldivide(ldividend, ldivisor);        int ans;    if (lans > Integer.MAX_VALUE){ //Handle overflow.        ans = (sign == 1)? Integer.MAX_VALUE : Integer.MIN_VALUE;    } else {        ans = (int) (sign * lans);    }    return ans;}private long ldivide(long ldividend, long ldivisor) {    // Recursion exit condition    if (ldividend < ldivisor) return 0;        //  Find the largest multiple so that (divisor * multiple <= dividend),     //  whereas we are moving with stride 1, 2, 4, 8, 16...2^n for performance reason.    //  Think this as a binary search.    long sum = ldivisor;    long multiple = 1;    while ((sum+sum) <= ldividend) {        sum += sum;        multiple += multiple;    }    //Look for additional value for the multiple from the reminder (dividend - sum) recursively.    return multiple + ldivide(ldividend - sum, ldivisor);}

然而reputation最高的是下面这个bit manipulation操作的solution 

In this problem, we are asked to divide two integers. However, we are not allowed to use division, multiplication and mod operations. So, what else can we use? Yeah, bit manipulations.

Let's do an example and see how bit manipulations work.

Suppose we want to divide 15 by 3, so 15 is dividend and 3 is divisor. Well, division simply requires us to find how many times we can subtract the divisor from the the dividend without making the dividend negative.

Let's get started. We subtract 3 from 15 and we get 12, which is positive. Let's try to subtract more. Well, we shift 3 to the left by 1 bit and we get 6. Subtracting 6 from 15 still gives a positive result. Well, we shift again and get 12. We subtract 12 from 15and it is still positive. We shift again, obtaining 24 and we know we can at most subtract 12. Well, since 12 is obtained by shifting 3to left twice, we know it is 4 times of 3. How do we obtain this 4? Well, we start from 1 and shift it to left twice at the same time. We add 4 to an answer (initialized to be 0). In fact, the above process is like 15 = 3 * 4 + 3. We now get part of the quotient (4), with a remainder 3.

Then we repeat the above process again. We subtract divisor = 3 from the remaining dividend = 3 and obtain 0. We know we are done. No shift happens, so we simply add 1 << 0 to the answer.

Now we have the full algorithm to perform division.

According to the problem statement, we need to handle some exceptions, such as overflow.

Well, two cases may cause overflow:

1. divisor = 0;
2. dividend = INT_MIN and divisor = -1 (because abs(INT_MIN) = INT_MAX + 1).

Of course, we also need to take the sign into considerations, which is relatively easy.

Putting all these together, we have the following code.

class Solution {public:    int divide(int dividend, int divisor) {        if (!divisor || (dividend == INT_MIN && divisor == -1))            return INT_MAX;        int sign = ((dividend < 0) ^ (divisor < 0)) ? -1 : 1;        long long dvd = labs(dividend);        long long dvs = labs(divisor);        int res = 0;        while (dvd >= dvs) {             long long temp = dvs, multiple = 1;            while (dvd >= (temp << 1)) {                temp <<= 1;//每次增大两倍                multiple <<= 1;            }            dvd -= temp;            res += multiple;        }        return sign == 1 ? res : -res;     }};