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

        }

    }

}

};

View Code

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

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;  

}  

View Code