Leetcode/ integer division

package com.xcrj;

/** *  Integer division  *  Given two integers  a  and  b , Find the quotient of their division  a/b , It is required that the multiplication sign... Shall not be used  '*'、 devide  '/'  And the remainder symbol  '%' . *  The result of integer division should be truncated （truncate） Its decimal part  *  Suppose our environment can only store  32  Bit signed integer   The range of values is  [−2^31, 2^31−1]. In this question , If the division result overflows , Then return to  2^31 − 1 * <p> *  Microcomputer principle ： Original code   Inverse code   Complement code  *  The original code is the binary used by people  *  The internal calculation of the computer is based on the complement  *  Positive numbers ： Original code = Inverse code = Complement code  *  negative ： Original code = The sign bit takes 1, Inverse code = The sign bit takes 1+ Reverse the value bit , Complement code = Inverse code + Last place plus 1= Add the inverse of the original code 1 * <p> *  Complement binary representation of signed numbers ：byte For example  * Integer.toHexString(v)  The output is a complement  * -128~127 * 0x80->0x7f * 1000,0000-+1->0111,1111 * <p> * java An operator  *  Will the displacement operator cause the original value of the variable to change  * <<  Move left , Low complement 0. amount to *2 * >>  Move right , High complement sign bit . amount to /2 * >>>  Move right   High compensation 0 * <p> *  Operator priority  * << >> >>> The operator of has priority over the arithmetic operator （ Including accumulation and subtraction ） All low . Higher priority than comparison operators .+= -= The combination operator has the lowest priority  */
public class Solution1 {
    
    /** *  The addition operator  */
    public static int divide(int a, int b) {
    
        int temp = 0;
        int quotient = 0;
        if (a > 0 && b > 0) {
    
            while (true) {
    
                temp += b;
                if (temp <= a) {
    
                    quotient++;
                } else {
    
                    return quotient;
                }
            }
        }

        if (a < 0 && b < 0) {
    
            while (true) {
    
                temp += b;
                if (temp >= a) {
    
                    quotient++;
                } else {
    
                    return quotient;
                }
            }
        }

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

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

        return quotient;
    }

    /** *  Shift left operator  */
    public static int divide2(int a, int b) {
    
        // Integer.MIN_VALUE/-1=-Integer.MIN_VALUE  Out of range 
        //  Deal with special cases first 
        if (a == Integer.MIN_VALUE && b == -1) {
    
            return Integer.MAX_VALUE;
        }
        //  Same sign judgment 
        boolean flag = false;
        if ((a < 0 && b < 0) || (a > 0 && b > 0)) {
    
            flag = true;
        }
        // a, b Take a negative number , Negative numbers represent a larger range than integers 1
        long dividend = a > 0 ? -a : a;
        long divisor = b > 0 ? -b : b;
        // - Divisor >- Divisor , Divisor < Divisor 
        //  Deal with special cases first 
        if (dividend > divisor) {
    
            return 0;
        }
        int result = 0;
        // ！！！ Use shift Record the number of shifts required for the divisor to be less than the dividend . Back let 1 Also displacement shift Times to get the result 
        int shift = 31;
        // - Divisor <=- Divisor , Divisor >= Divisor 
        //  When is the divisor less than the dividend 
        while (dividend <= divisor) {
    
            //  Divisor < Divisor , Keep moving left 
            //  How many divisors to weigh 2 Is smaller than the dividend 
            while (dividend > divisor << shift) {
    
                shift--;
            }
            //  Divisor - The divisor part continues 
            dividend -= divisor << shift;
            //  Acquisition quotient 
            result += 1 << shift;
        }
        return flag ? result : -result;
    }

    public static void main(String[] args) {
    
        System.out.println(divide(9, 1));
    }
}