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;
}