Leetcode50.Power(x,n)

一、题目

实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。

示例 1：

输入：x = 2.00000, n = 10
输出：1024.00000
示例 2：

输入：x = 2.10000, n = 3
输出：9.26100
示例 3：

输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25

提示：

-100.0 < x < 100.0
-231 <= n <= 231-1
-104 <= xn <= 104

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/powx-n
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、代码实现

主要就只有递归和遍历去实现。暴力法O(n)，但是可以通过优化实现O(logn)的时间，当然代价则是相应的空间。我在遍历的时候采用hash表去存储，耗空间O(logn)，其实集合类是非常耗效率的，所以更推荐用空间栈(递归)。而且在代码简洁性上，递归更是有着不可撼动的竞争力。

1、遍历实现

class Solution {
    public double myPow(double x, int n) {
        //主要是为了防止logn中的n=0出现异常
      if(n==0)return 1;
      boolean mark = n > 0 ? true : false;
        double ans = 1;
        if (n == Integer.MIN_VALUE) {
            n = Integer.MAX_VALUE;
            ans = x;
        }
        n = n > 0 ? n : -n;
        int curN = 1;
        double curX = x;
        //既然知道所需空间，则直接在创建时就给容量，效率会更好
        HashMap<Integer, Double> map = new HashMap<>((int)Math.log(n)+1);
        map.put(0,1.0);
        while (n > 0) {
            boolean isIncreased = true;
            if (curN <= n) {
                ans *= curX;
                n -= curN;
                if (isIncreased) {
                    map.put(curN, curX);
                    //用移位符会更快
                    curN <<= 1;
                    curX *= curX;
                }
            }
            /*bug积累
            在最后n-0时，curN或许也会执行到0，所以需要对其进行特殊处理,否则会出现nullpointer Exception
             */
            while (curN > n) {
                curN >>=1;
                curX = map.get(curN);
                isIncreased = true;
            }
        }
        return mark ? ans : 1 / ans;
    }
}

二、递归

class Solution {
    public double myPow(double x, int n) {
      //递归中止条件最好放在最前面，像先前那种n改变了导致错误的情况就不会发生了
        if (n == 2) return x * x;
        if (n == 1) return x;
        if (n == 0) return 1;
        boolean mark = false;
        if (n == Integer.MIN_VALUE) {
            mark = true;
            n = Integer.MAX_VALUE;
        }
        boolean key = n > 0 ? true : false;
        /*bug积累:
        注意重新赋值语句一定要放在逻辑判断语句的后面，否则就会出现(2,-1)返回2的情况了
         */
        n = n > 0 ? n : -n;
        if (!mark) {
            if (n % 2 == 0)
                return key ? myPow(myPow(x, n >> 1), 2) : 1 / myPow(myPow(x, n >> 1), 2);
            return key ? myPow(myPow(x, n >> 1), 2) * x : 1 / (myPow(myPow(x, n >> 1), 2) * x);
        }
        return 1 / (myPow(myPow(x, n >> 1), 2) * myPow(x,2));
    }
}

三、递归的优化

二中递归的诟病非常明显，太多的中止条件判断，太多的重复计算式，太多的boolean标志，使得看上去是非常复杂。参照了leetcode官方的答案，优化了二中的代码，从十六行核心代码精炼到了四行。

/*
优化
    1、对于反复出现的一个值，我们创建一个临时变量来承载，会更加简洁美观
    创建一个临时变量来承载反复出现的(myPow(x, n >> 1)
    2、对于n是正是负，其实只有第一次判断是有效判断，为了解决冗余代码，我们另
    建一个函数，这样代码不仅更加简洁，同时也可以节省一些时间
    3、用long承载了防止溢出,这样就会少一个讨论项目
    long的范围是-9223372036854775808到9223372036854775807(可以用Long.MIN_VALUE和Long.MAX_VALUE去承载)
     */
class Solution {
    public  double myPow(double x, int n) {
        return n > 0 ? solve(x, n) : 1 / solve(x, -(long) n);
    }
    
    private  double solve(double x, long n) {
        if (n == 0) return 1;
        double y = solve(x, n >> 1);
        return n % 2 == 0 ? y * y : y * y * x;
    }
}