剑指 Offer II 001. 整数除法

给定两个整数 a 和 b ，求它们的除法的商 a/b ，要求不得使用乘号 ‘*’、除号 ‘/’ 以及求余符号 ‘%’ 。

注意：

整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2
假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−231, 231−1]。本题中，如果除法结果溢出，则返回 231 − 1

基本思路：
不能使用条件中限制的方法-》除法的基本来源就是减法

一.初版方案：

 private static 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;
        //使用减法一个一个的减去除数
         while (a >= b) {
             a -= b;
             res++;
         }
        return sign == 1 ? res : -res;
    }

但是存在问题
当a == Integer.MIN_VALUE-》Math.abs(a)仍然是Integer.MIN_VALUE，int类型超出范围，
题目要求不能使用超过32位的-》不能使用long
a = Math.abs(a);
b = Math.abs(b);
思路转变 ：将所有正数转变为负数 就不会出现越界的
但是会存在一个超时的问题 比如a = Integer.MAX_VALUE, b = 1时， 需要执行Integer.MAX_VALUE次

 private static 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;
          if (a > 0) a =  -a;
           if (b > 0) b = -b;  
         int res = 0;
        //使用减法一个一个的减去除数
         while (a <= b) {
             a -= b;
             res++;
         }
        return sign == 1 ? res : -res;
    }     

二. 优化方案：可减去 除数的倍数
比如 : 15 - 2 = 13 > 0 1 个 2 -> k 记录2的个数
15 - （2+2） = 8 > 0 2 个 2
15 - (4+4) = 7 > 0 4 个 2
15 - (8+8) = -1 < 0
即 res += k
越界问题考虑：

 判断 value >= 0xc0000000 的原因：保证 value + value 不会溢出
  可以这样判断的原因是：0xc0000000 是最小值 -2^31 的一半，而 a 的值不可能比  -2^31  还要小，所以 value 不可能比 0xc0000000 小, -2^31 / 2 = -2 ^30;

private static 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;
          if (a > 0) a =  -a;  
           if (b > 0) b = -b;  
         int res = 0;
        //使用减法一个一个的减去除数
         while (a <= b) {
             int value = b;
             int k = 1;//记录value的个数
             //所有正数转负数 所以是 a < value+value
             while (value >= 0xc0000000 && a <= value+value) {
                value += value;
                k += k;
             }
             a -= value;
             res += k;
         }
        return sign == 1 ? res : -res;
    }     

三. 优化 -》位运算
优化点还是在计算这块
15 - ( 2<<0 )= 13 > 0 1 个 2 -> k 记录2的个数1<<0
15 - （2<<1） = 8 > 0 2 个 2 1<<1
15 - (2<<2) = 7 > 0 4 个 2 1<<2
15 - (2<<3) = -1 < 0
即 res += k

private static int divide3(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--) {
            //若进a- (b << i) > 0但是其中b>>i会存在越界的问题
            //所以a >> i，就不会存在越界问题， 若a是Integer.MIN_VALUE,
            //a>>>i无符号的运算
            //a >>> i >= b 当b是最小值的， 此条件就一直是true,，所以（a>>>i）- b >=0 就会为false
            if ((a >>> i) - b>= 0 ) {
                a -= (b << i);
                res += (1 << i);

            }
        }
        return sign == 1 ? res : -res;
    }