剑指 Offer II ------题记（一）

001. 整数除法

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

注意：

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

示例 1：

输入：a = 15, b = 2
输出：7
解释：15/2 = truncate(7.5) = 7
示例 2：

输入：a = 7, b = -3
输出：-2
解释：7/-3 = truncate(-2.33333..) = -2
示例 3：

输入：a = 0, b = 1
输出：0
示例 4：

输入：a = 1, b = 1
输出：1
 

提示:

• - <= a, b <=  - 1
• b != 0

我最开始写的不成熟代码（就想着用减法代替除法）

class Solution {
    public int divide(int a, int b) {
        int i=0;
        if(a==-2147483648&&b==-1)return 2147483647;
        if(a>=0&&b>0)
        {
            while((a-=b)>=0){
                i++;
            }
        }else if(a<0&&b>0){
            a=-a;
            while((a-=b)>=0){
                i--;
            }

        }else if(a>=0&&b<0){
            b=-b;
             while((a-=b)>=0){
                i--;
            }

        }else if(a<0&&b<0){
            a=-a;
            b=-b;
            while((a-=b)>=0){
                i++;
            }

        }
        return i;
    }
}

可发现编译总是超时，简单的优化也无济于事，即使运行成功也是勉强通过。

下面是别人的代码，值得学习借鉴。（但是也超时了）

 一.

class Solution {
    public int divide(int a, int b) {
    // 32 位最大值：2^31 - 1 = 2147483647
    // 32 位最小值：-2^31 = -2147483648
    // -2147483648 / (-1) = 2147483648 > 2147483647 越界了
    if (a == Integer.MIN_VALUE && b == -1)
        return Integer.MAX_VALUE;
    int sign = (a > 0) ^ (b > 0) ? -1 : 1;
    // 环境只支持存储 32 位整数
    if (a > 0) a = -a;
    if (b > 0) b = -b;
    int res = 0;
    while (a <= b) {
        a -= b;
        res++;
    }
    // bug 修复：因为不能使用乘号，所以将乘号换成三目运算符
    return sign == 1 ? res : -res;
    }
}

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

会超时的原因：

  当被除数很大而除数很小的情况下，while会循环很多次。会很慢！！！！

二.尝试去减掉除数的倍数

// 时间复杂度：O(logn * logn)，n 是最大值 2147483647 --> 10^10
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;
    if (a > 0) a = -a;
    if (b > 0) b = -b;
    int res = 0;
    while (a <= b) {
        int value = b;
        int k = 1;
        // 0xc0000000 是十进制 -2^30 的十六进制的表示
        // 判断 value >= 0xc0000000 的原因：保证 value + value 不会溢出
        // 可以这样判断的原因是：0xc0000000 是最小值 -2^31 的一半，
        // 而 a 的值不可能比 -2^31 还要小，所以 value 不可能比 0xc0000000 小
        // -2^31 / 2 = -2^30
        while (value >= 0xc0000000 && a <= value + value) {
            value += value;
            k += k;
        }
        a -= value;
        res += k;
    }
    // bug 修复：因为不能使用乘号，所以将乘号换成三目运算符
    return sign == 1 ? res : -res;
}

• 时间复杂度：O(logn * logn) ，使用 python 和 javascript 会超时，看下面的优化
• 空间复杂度：O(1)

这个理解也简单：

  就是成倍数去减，减到不能减就换个除数重新开始减，再累加倍数。

 值得学习的点：

1.  用sign来判断最后的结果是正还是负
2.  灵活使用三目运算符
3.  要尽可能的去减少运算量

改变方法------位运算

class Solution {
    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)
            a -= (b << i);
            res += (1 << i);
        }
    }
    // bug 修复：因为不能使用乘号，所以将乘号换成三目运算符
    return sign == 1 ? res : -res;
    }
}

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