Divide Two Integers

/*
Solution using all int variables. Long is not used.
Time Complexity = O(log n) -> where n is the dividend
Search space is (dividend - divisor).. Every while loop we will reduce the search space by half.
Space Complexity = O(1)
*/
class Solution {
    public int divide(int dividend, int divisor) {
        if (divisor == 0) {
            return Integer.MAX_VALUE;
        }
        if (divisor == 1) {
            return dividend;
        }
        if (dividend == divisor) {
            return 1;
        }

        int intMinOverflow = 0;

        if (dividend == Integer.MIN_VALUE) {
            if (divisor == -1) {
                return Integer.MAX_VALUE;
            } else {
                intMinOverflow = 1;
            }
        }

        if (divisor == Integer.MIN_VALUE) {
            return 0;
        }
        if (divisor == -1) {
            return ~dividend + 1;
        }

        int result = 0;
        boolean resultSign = (dividend < 0) ^ (divisor < 0);

        int dividendAbs = Math.abs(dividend + intMinOverflow);
        int divisorAbs = Math.abs(divisor);

        while (dividendAbs >= divisorAbs) {
            int divisorTemp = divisorAbs;
            int multiple = 1;
            while (dividendAbs >= (divisorTemp << 1) && ((divisorTemp << 1) >> 1) == divisorTemp) {
                divisorTemp <<= 1;
                multiple <<= 1;
            }
            dividendAbs -= divisorTemp;
            dividendAbs += intMinOverflow;
            intMinOverflow = 0;
            result += multiple;
        }

        return resultSign ? ~result + 1 : result;
    }
}

/*
In the following solution long is used to store the intermediate values.
Time Complexity = O(log n) -> where n is the dividend
Space Complexity = O(1)
*/
// class Solution {
//     public int divide(int dividend, int divisor) {
//         if (divisor == 0) {
//             return Integer.MAX_VALUE;
//         }
//         if (divisor == 1) {
//             return dividend;
//         }

//         if (dividend == Integer.MIN_VALUE) {
//             if (divisor == -1) {
//                 return Integer.MAX_VALUE;
//             } else if (divisor == Integer.MIN_VALUE) {
//                 return 1;
//             }
//         }

//         if (divisor == Integer.MIN_VALUE) {
//             return 0;
//         }
//         if (divisor == -1) {
//             return ~dividend + 1;
//         }

//         int result = 0;
//         boolean resultSign = (dividend < 0) ^ (divisor < 0);

//         long dividendAbs = Math.abs((long) dividend);
//         long divisorAbs = Math.abs((long) divisor);

//         while (dividendAbs >= divisorAbs) {
//             long divisorTemp = divisorAbs;
//             long multiple = 1;
//             while (dividendAbs >= (divisorTemp << 1)) {
//                 divisorTemp <<= 1;
//                 multiple <<= 1;
//             }
//             dividendAbs -= divisorTemp;
//             result += multiple;
//         }

//         return resultSign ? ~result + 1 : result;
//     }
// }