leetcod Pow(x, n)

题目：就是实现一个指数函数。

直接用一个while一直乘以n词肯定是会超时的。

自己写了用递归（而且是很挫的递归），测试了无数次，根据每个case去修改代码。终于可以AC了。不忍直视，自己写了好长，如下：

class Solution {
public:
    double pow(double x, int n) {
    int flag1 = 0, flag2 = 0;
    if (n < 0)
    {
        flag1 = 1;
        if (n > INT_MIN)  n = -n;
        else
        {flag2 = 1; n = -(n + 1);}
    }
    if (n == 0 || x == 1)
        return 1;
    if (x == 0)
        return 0;
    int time = (int) (log(n)/log(2));
    double ans = x;
    int cnt = 1;
    while(time--)
    {
        cnt <<= 1;
        ans *= ans;
    }
    if(!flag2)
    {
        if (cnt == n)
        {   
            if(flag1)
                return 1/ans;
            return ans;
        }
        else
        {   
            if (flag1)
                return 1/(ans*pow(x, n - cnt));
            return ans*pow(x, n - cnt);
        }
    }
    else
    {
        if (cnt == n)
        {
            if (flag1)
                return 1/(ans*x);
            return ans*x;
        }
        else
        {
            if (flag1)
                return 1/(x*ans*pow(x, n-cnt));
            return x*ans*pow(x, n - cnt);
        }
    }
}
};

然后肯定要看看其他大神。用递归的，别人十几行就搞定了。

double pow(double x, int n) {  
    if (n == 0) return 1.0;  
    double half = pow(x, n/2);  
    if (n%2 == 0)  
    {  
        return half*half;  
    }  
    else if (n>0)  
    {  
        return half*half*x;  
    }  
    else  
    {  
        return half/x*half;  
    }  
}  

以下有一个没有用递归的。

public double pow(double x, int n) {  
    if(n==0)  
        return 1.0;  
    double res = 1.0;     
    if(n<0)  
    {  
        if(x>=1.0/Double.MAX_VALUE||x<=1.0/-Double.MAX_VALUE)  
            x = 1.0/x;  
        else  
            return Double.MAX_VALUE;  
        if(n==Integer.MIN_VALUE)  
        {  
            res *= x;  
            n++;  
        }  
    }  
    n = Math.abs(n);  
    boolean isNeg = false;  
    if(n%2==1 && x<0)  
    {  
        isNeg = true;  
    }  
    x = Math.abs(x);  
    while(n>0)  
    {  
        if((n&1) == 1)  
        {  
            if(res>Double.MAX_VALUE/x)  
                return Double.MAX_VALUE;  
            res *= x;  
        }  
        x *= x;  
        n = n>>1;  
    }  
    return isNeg?-res:res;  
}