剑指 Offer II 001. 整数除法

这个虽说简单题，缺少逆向思维，很难完成。

【思路概要】：

• 累减 代替 除法   （会超时）
• 位运算             （主要使用位移运算 简化 其中循环操作，目的快速是被除数减小） 

 第一种方法：（会超时）

class Solution:
    def divide(self, a: int, b: int) -> int:
        #使用减法来代替除法
        #定义最大值和最小值
        INT_MAX,INT_MIN = 2**31 -1  , -2**31
         #鲁棒性检查
        if (a == INT_MIN and b == -1):
            return INT_MAX
        #存放符号
        sign = -1  if (a >0) ^ (b > 0) else 1     #异或运算，同则为假 ， 异则为真
        #转换为负数计算,避免2的31次方越界
        if a >0 :
            a = -a
        if b > 0 :
            b = -b
        res = 0
        #当a < b时 循环 累减
        while a <= b:
            #设置 用加法模拟 b的倍数，加速减法
            value , k = b , 1
            #避免两个value和越界，value不能超过 0xc0000000
            while value >= 0xc0000000 and a <= value +value:
            #代码优化：如果 k 已经大于最大值的一半的话，那么直接返回最小值
            #因为这个时候 k += k 的话肯定会大于等于 2147483648 ，这个超过了题目给的范围
                value +=value
                if k > INT_MAX >> 1:
                    return INT_MIN
                k += k
            
            res , a = res+k , a- value
        return res if sign == 1 else -res

第二种方法：

class Solution:
    def divide(self, a: int, b: int) -> int:
        #使用减法来代替除法
        #定义最大值和最小值
        INT_MAX,INT_MIN = 2**31 -1  , -2**31
         #鲁棒性检查
        if (a == INT_MIN and b == -1):
            return INT_MAX
        res = 0
        #处理边界，防止正数边界溢出
        if b == INT_MIN: #除数 绝对值最大，结构为 0 或 1
            return 1 if a==b else 0
        if a == INT_MIN:  #被除数绝对值为最大值
            a -= -abs(b)
            res +=1
        #存放符号
        sign = False  if (a >0) ^ (b > 0) else True     #异或运算，同则为假 ， 异则为真
        #转换为负数计算,避免2的31次方越界

        a , b = abs(a) , abs(b)   #转为正数

        for i in range(31 , -1, -1):   #从 31 到 -1 ，每次-1
            if a >>i >= b:      #a / 2 ^i >=b 即 a >= b*2 ^ i 这里不直接对b操作，防止溢出
                a -= b <<i
                if res > INT_MAX - ( 1<< i):  #控制res >= INT_MAX
                    return INT_MIN
                res += 1 << i   #当上条件满足，
            
        return res if sign else -res

时间复杂度O(1) , O（n）