剑指offer：001. 整数除法

给定两个整数 a 和 b ，求它们的除法的商 a/b ，要求不得使用乘号 ‘*’、除号 ‘/’ 以及求余符号 ‘%’ 。
注意：
整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2
假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−2³¹, 2³¹−1]。本题中，如果除法结果溢出，则返回 2³¹ − 1

思路：
0、题目分析，不能使用乘除余，向下取整。溢出返回最大值。溢出考虑的是-2147483648/-1 = 2147483648 就会溢出 返回最大值
1、不能使用除法，同符号的情况下，可以用减法代替除法。减掉多少个b，就说明除的结果是多少。
2、将两个数字转化为同符号，需要再判断结果的正负关系。 除法两个数同号为正异号为负（相同为正，相异为负 异或^）。

解法一：

class Solution {
    public int divide(int a, int b) {
    		//溢出限定
        if(a==Integer.MIN_VALUE&&b==-1){
            return Integer.MAX_VALUE;
        }
        //判断结果正负号
        int flag = (a>0)^(b>0)?-1:1;
        //将两个数字都转为负数，原因是
        // 都转为负是因为负数转正数会导致越界
        if(a>0) a = -a;
        if(b>0) b = -b;
        int count = 0;
        while(a<=b){
            count++;
            a = a - b;
        }
        return flag>0?count:-count;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

解法二：
思路：改进第一种解法，在while循环中，是一个个减b，导致的复杂度上升。
改进：在循环中尽量最多的b。
比如：22-3=21>0；22-32=15>0；22-32*2=10>0 ； 则一次外循环就减去 12。第二次外循环就变为 10-3。最终算出答案

class Solution {
    public int divide(int a, int b) {
        if(a==Integer.MIN_VALUE&&b==-1){
            return Integer.MAX_VALUE;
        }
        int flag = (a>0)^(b>0)?-1:1;
        if(a>0) a = -a;
        if(b>0) b = -b;
        int count = 0;
        while(a<=b){
            int value = b;
            int k = 1;
            //value>=0xc0000000  0xc0000000是-2^31/2 防止 value*2越界  
            while(value>=0xc0000000 && a<=value+value){
            		//每次减的为上一次的两倍
                k+=k;
                value+=value;
            }
            count+=k;
            a-=value;
        }
        return flag>0?count:-count;
    }
}

时间复杂度：O(logn)O(logn)
空间复杂度：O(1)

解法三：位运算

// 时间复杂度：O(1)
public int divide(int a, int b) {
    if (a == Integer.MIN_VALUE && b == -1)
        return Integer.MAX_VALUE;
    int sign = (a > 0) ^ (b > 0) ? -1 : 1;
    a = Math.abs(a);
    b = Math.abs(b);
    int res = 0;
    for (int i = 31; i >= 0; i--) {
        // 首先，右移的话，再怎么着也不会越界
        // 其次，无符号右移的目的是：将 -2147483648 看成 2147483648

        // 注意，这里不能是 (a >>> i) >= b 而应该是 (a >>> i) - b >= 0
        // 这个也是为了避免 b = -2147483648，如果 b = -2147483648
        // 那么 (a >>> i) >= b 永远为 true，但是 (a >>> i) - b >= 0 为 false
        if ((a >>> i) - b >= 0) { // a >= (b << i)
        //每次减的是最多的b
            a -= (b << i);
            res += (1 << i);
        }
    }
    return sign == 1 ? res : -res;
}

时间复杂度：O(1)
空间复杂度：O(1)

You dot a dream，you gotta protect it，if you want something，go get it.
如果你有梦想，就要守护它，如果你想要什么，就去实现它。