Divide Two Integers

 视频讲解  http://v.youku.com/v_show/id_XMTY1MTAyODM3Ng==.html

int 范围：

Integer.MIN_VALUE   =>   -2147483648

Integer.MAX_VALUE   =>   2147483647

overflow:

当被除数为 Integer.MIN_VALUE的时候，取绝对值或者除以－1都会造成溢出overflow.

Math.abs(-2147483648)   =>  -2147483648

Integer.MIN_VALUE/(-1)  =>   -2147483648

(1)把两个数转化成long类型，可以得到正确的绝对值

Long.MAX_VALUE   =>   9223372036854775807

Long.MIN_VALUE  =>   -9223372036854775808

long a = Math.abs((long)dividend);

long b = Math.abs((long)divisor);

Math.abs((long)-2147483648)  =>  2147483648

(2)题目中给出If it is overflow, return MAX_INT.

if(dividend == Integer.MIN_VALUE && divisor == -1)     

     return Integer.MAX_VALUE;

a=0,b=0, leetcode这道题中这个test case没有处理，所以暂时不需要考虑。

a<b, 被除数小于除数，结果为0。

a>=b,  通过b位移来得到b和a之间的倍数关系。

 

   4<<1  => 4*2，

   4<<2  => 4*2*2,

   4<<3  => 4*2*2*2,

a=25, b=4, result =0

当a>＝b, a>0,b>0

    int count =0;记录位移的位数，

    如果a> b<<(count+1), count++;

 (1) count =0:  25 > 4<<1,  4*2=8 , count++;

    count=1:   25 > 4<<2,  4*2*2=16, count++;

    count=2:   25 > 4<<3,  4*2*2*2=32不成立，

    本轮循环结束，count=2;

     result += 1<<count;  result =1*2*2=4;

     a -= b<<count, a = 25 - 4*2*2 =9;

 

 (2)count=0, 9 > 4<<1, 4*2=8,count++;

     count=1, 9 > 4<<2, 4*2*2=16不成立，count=1

     本轮结束循环， count=1,

      result += 1<<count; result=4+1*2=6;

      a -= b<<count,  9-4*2=1, 1<4整个循环结束

由于a和b是被除数和除数的绝对值，如何判断两者符号是否相同？

 

    1^1  => 0

    1^0  => 1

    true^false    => true

    true^true     => false

    false^false  => false

 

    ((dividend>0)^(divisor>0))?(-result):result

 

    符号相同则为false，取result

    不同则为true，取-result的值

 

public class Solution {
    public int divide(int dividend, int divisor) {
        
        if(dividend == Integer.MIN_VALUE && divisor == -1) return Integer.MAX_VALUE;
        
        long a = Math.abs((long)dividend);
        long b = Math.abs((long)divisor);
        
        if(a<b) return 0;
        
        int result = 0;
        
        while(a>0 && b>0 && a>=b){
            int count = 0;
            while(a> b<<(count+1)){
                count++;
            }
            result += 1<<count;
            a -= b<<count;
        }
        return ((dividend>0)^(divisor>0))?(-result):result;
    }
}