leetcode 50: 快速幂(非递归与递归)

题解

• 题意：实现函数pow(x,n)，其中x是double类型，n是int类型(n是)
  • 除了快速幂算法之外，还要注意int类型的正负号取值范围不一样。
• 题解：快速幂算法（分治思想）
  • 举两个例子，求$x^{64}$， 和$x^{10}$
    • $x^2=(x\ast x)\to x^4=(x^2)\ast (x^2)\to x^8=(x^4)\ast (x^4)\ast x\to x^{16}=x^8\ast x^8\to x^{32}=x^{16}\ast x^{16}\to x^{64}=x^{32}\ast x^{32}$，6次操作
    • $x^2=x\ast x\to x^4=(x^2\ast x^2)\to x^8=(x^4)\ast (x^4)\to x^{10}=(x^2)\ast (x^8)$，4次操作
  • 可以看到，其实求幂的复杂度可以缩减为$o(lo{g}_{2}n)$，从复杂度上来看，可以推测快速幂就是对指数进行分治
  • 上面的步骤是怎么来的呢？
    • 如果n是2^x，那么过程很好理解，就是每次划分都只需要求一半数据n/2，另一半翻倍即可，换成二进制就是64=1000000，等价于1左移6位。
    • 如果n不是，那就转换为2^x和另一部分，以此类推，那这其实和二进制串计算的过程完全吻合，比如10=1010，那么计算的过程中，就是看成1000+0010，等价于1左移1位加上1左移3位，再举个例子，15=1111,那么就是$1000+0111\to 1000+0100+0011\to 1000+0100+0010+0001$
• 实现：实现的过程中，我们需要有两个变量，一个从1开始，不断计算当前位对应的值，另一个则累加1出现的位置的值，不过这都是指数层面的运算，换成实际数据，要对操作进行升级（加法变乘法）
• 非递归

class Solution {
    public double myPow(double x, int n) {
        long d = n;
        double res = 1, tmp = x;
        if(n<0) d=-d;
        while(d!=0){    
            if((d&1)>0)
                res = tmp*res;
            tmp = tmp * tmp;
            d>>=1;
        }
        return n>0?res:1.0/res;
    }
}

• 递归，来自leetcode题解，不过这个空间复杂度高一些，因为递归函数占用了栈空间

	class Solution {
	    public double quickMul(double x, long N) {
	        if (N == 0) {
	            return 1.0;
	        }
	        double y = quickMul(x, N / 2);
	        return N % 2 == 0 ? y * y : y * y * x;
	    }
	
	    public double myPow(double x, int n) {
	        long N = n;
	        return N >= 0 ? quickMul(x, N) : 1.0 / quickMul(x, -N);
	    }
	}

题目

• pow(x, n)