Leetcode - Pow(x, n)

[分析] 数值计算类型题目，二分法或者借助位运算，本题两种方法都可解。实现1是二分法思路，缺点是递归可能导致栈溢出。实现2是借助位运算，并进行了各种溢出检查和处理。实现3同样是位运算法，除了计算过程使用long类型的n外没有进行其他溢出保护，代码非常简洁，利于理解题目本身思路，实际应用中需要像实现2那样做溢出检查以保证程序的健壮性。

[ref]
http://www.cnblogs.com/TenosDoIt/p/3802902.html
http://blog.csdn.net/linhuanmars/article/details/20092829

public class Solution {
    // Method 1: 二分法
    public double myPow1(double x, int n) {
        if(n == 0)
            return 1;
		
        if(x == 0)
            return 0;
        else if(x == 1)
            return 1;
        else if(x == -1){
            return ((n & 1) == 1) ? -1 : 1;
        }
        
        double half = myPow(x, n / 2);
        if((n & 1) == 0)//even
            return half * half;
        else if(n > 0)
            return half * half * x;
        else 
            return half * half / x;
    }
    // Method 2：位运算, 包含各种防溢出处理
    public double myPow2(double x, int n) {
        if (x == 0)
            return 1;
        double res = 1.0;
        if (n < 0) {
            if (x >= 1.0 / Double.MAX_VALUE || x <= 1.0 / Double.MIN_VALUE)
                x = 1.0 / x;
            else
                return Double.MAX_VALUE;
            if (n == Integer.MIN_VALUE) {
                res *= x;
                n++;
            }
        }
        boolean isNeg = false;
        if (x < 0 && (n & 1) == 1)
            isNeg = true;
        x = Math.abs(x);
        n = Math.abs(n);
        while (n > 0) {
            if ((n & 1) == 1) {
                if (res < Double.MAX_VALUE / x)
                    res *= x;
                else
                    return Double.MAX_VALUE;
            }
            x *= x;
            n >>= 1;
        }
        return isNeg ? -res : res;
    }
    // Method 3: 位运算，不检查溢出
    public double myPow(double x, int n) {
        if (x == 0)
            return 1;
        double res = 1.0;
        long nn = n;
        if (nn < 0)
            nn = -nn;
        while (nn > 0) {
            if ((nn & 1) == 1) {
                res *= x;
            }
            x *= x;
            nn >>= 1;
        }
        return n >= 0 ? res : 1.0 / res;
    }
    
}