Leetcode -- Divide Two Integers

问题链接：https://oj.leetcode.com/problems/divide-two-integers/

问题描述：

Divide two integers without using multiplication, division and mod operator.

If it is overflow, return MAX_INT.（实际上就是实现除法）

问题API：public int divide(int dividend, int divisor)

问题分析：最低级的做法就是循环减...就是判断一下dividend和divisor之间的正负关系和过界关系，然后dividend循环减divisor然后计数器不停加一。这个做法必然是不受待见的。

其实关于所有加减乘除，本质上都是在问bit operation。

这里先解答如何做除法。除法其实就相当于二进制减法，如果想偷懒一点就可以直接从divisor左移31位到左移0位相减。这里你可以甚至认为这是一个constant time的算法，因为永远只需要算31次。但是这样并不效率。要效率的做就需要考虑到dividiend和divisor用二进制表示到底有多少位，然后取差值，从差值开始循环递归到0。

举个例子，9用二进制表示就是1001，四位，2用二进制表示就是10， 它们之间的位数差就是2，就从i == 2开始循环到 i == 0， 也就是9 -  2 << 2 , 此时结果为1，再循环到i == 1和i == 0时，1 都比divisor << i要小。所以最终结果就是 1 << 2 = 4

另外，这题还有两个case要小心处理，一个是负数，负数就用boolean值来标记就好，另一个就是过界处理，一般这种加减乘除或者算数的题目，用long会是一个很tricky的做法，你所有input都是Integer,用long就不会过界，而且过界检测也变得很简单。但是这里讲解的就不是用Long这种犯规工具，直接用int做检测。具体看代码comment。

    // return 底数为log的值
    public double log(int a, int n){
        return Math.log(a) / Math.log(n);
    }
    
    public int divide(int dividend, int divisor) {
        int res = 0;
        if(divisor == 0 || dividend == Integer.MIN_VALUE && divisor == -1){//从结果上来看，这题唯一结果会出界的情况就是两种，
           return Integer.MAX_VALUE;//第一种就是除数为0，第二种就是被除数是MIN_INT，除数是-1。这样的结果就会超过MAX_INT而过界。
        }else if(divisor == Integer.MIN_VALUE)
            return dividend == Integer.MIN_VALUE ? 1 : 0;
        else if(dividend == Integer.MIN_VALUE){// overflow case of minimum integer
            dividend += Math.abs(divisor);//这是一种很特殊的过界处理方法，因为在下面我们会将负数取反，但MIN_INT取反会导致整数过界，所以先结果加一
            res++;
        }
        boolean isNeg = ((dividend ^ divisor) & (1 << 31)) != 0;
        dividend = Math.abs(dividend);
        divisor = Math.abs(divisor);
        int bit_dividend = (int)log(dividend, 2);
        int bit_divisor = (int)log(divisor, 2);
        int diff = bit_dividend - bit_divisor;
        for(int i = diff; i >= 0; i--){
            if(dividend >= divisor << i/* || dividend >> i >= divisor*/){//如果不是从diff开始而是从31开始，则后者是需要的一种过程过界判断
                res += 1 << i;
                dividend -= divisor << i;
            }
        }
        return isNeg ? -res : res;
    }

下面给出的是加法的做法：

实际上加法要比乘除相对简单很多。

基本就两步循环。如果求的是add(a,b)

int c = a ^ b;

int d = a & b << 1;

a = c;

b = d;

直到b == 0为止。其中在这里，a ^ b 表示的是没有进位的加法，因为0 + 0 = 0, 1 + 0 = 1, 1 + 1 = 10。b表示的是进位，只有在都是1的情况下会出现1， 然后左移一位10。然后不停将子结果和进位进行无进位相加。直到没有进位为止。下面是代码：

	public static int add(int a, int b){
		while(b != 0){
			int c = a ^ b;
			int d = (a & b) << 1;
			a = c;
			b = d;
		}
		return a;
	}

下面给出的是基于上述加法的减法。其实substract(a,b)从数字逻辑的角度去看就是a和b的补码相加。于是将b的补码通过加法得到，再与a相加即可。

	public static int substract(int a, int b){
		return add(a, add(~b,1));// 提一下数字逻辑的基础，b的反码加1就是补码，相减其实就是和减数的补码相加。。。。。
	}

下面给出的是和除法类似的乘法，其实都是从高位到低位的左移相加/减，具体算法就不解释了，大家看代码理解就好：

	public static int multiply(int a, int b){
		int c = 0;
		boolean nega = false, negb = false;
		if(a < 0){
			nega = true;
			a = -a;
		}
		if(b < 0){
			negb = true;
			b = -b;			
		}
		
		int bits = (int)(Math.log(b) / Math.log(2));// 对数换底公式，最后变成了log2(b)
		for(int i = bits; i >= 0; i--){
			if((1 << i & b) == 0){
				c <<= 1;
			}else{
				c <<= 1;
				c = add(a,c);
			}
		}
		if(nega ^ negb){
			c = -c;
		}
		return c;
		
	}