一、题目
实现 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;
}
}