循环的思路是 x^n 等价于 (x * x) ^ (n/2) 【如果n除以2余1就得在后面乘以一个x补上】, 继续等价于 (x^2 * x^2) ^ (n/4) 【如果n除4余1再乘以一个x^2补上】，用纯文字描述就是随着n不断地除以2减小，x不断地平方来扩大，直到n为1结束，这个时候的x就是最后的结果了，但是每次循环都要对n为奇数的情况做一个填补。因为x是以不断平方自己的方式来到达最后的终点，所以复杂度是logN
不考虑边界情况和复数的java代码如下
        double result = 1.0d;
        while(n > 0) {
            if((n & 1) == 1) {
                result = result * x;
            }
            x = x*x;
            n = n/2;
        }
        return result;

按老师的递归算法直接扑街了!java的直接上代码,处理(0.00001,2147483647)直接提示超时
    public double myPow(double x, int n) {
        if (n == 0) return 1;
        if (n < 0){
            return 1/myPow(x,-n);
        }
        if (n % 2 ==0){
            return myPow(x,n/2)*myPow(x,n/2);
        }else{
            if (n % 2 !=0) return x*myPow(x,n/2)*myPow(x,n/2);
        }

        return 0;
    }

反复平方的办法（没对溢出做处理）    
public static int pow(int a,int b) {
        int ret = 1;
        int base = a;
     while (b != 0) {
     if ((b & 1) != 0)
     ret *= base;
     base *= base;
     b >>= 1;
     }
     return ret;
    }

function myPow(x, n){
    if(n === 0){
        return 1
    }

    if(n < 0){
        return 1 / myPow(x, -n)
    }

    if(n % 2){
        return x * myPow(x, n-1)
    }

    return x*x * myPow(x, n - 2) // 这一步视频里面应该不对吧？
}

按照递归来写的，结果报栈溢出。修改下方法，基本逻辑都没变，就没有栈溢出了，求答案。
public static void main(String[] args) {
        double x = 2;
        int n = -2147483648;
        System.out.println(myPow(x,n));
    }

public static double myPow(double x, int n) {
        if(x == 0.0 || x == 1.0) {
            return x;
        }
        
        if(n==0) {
            return 1;
        }
        
        if(n<0) {
            x = 1/x;
            n = -n;
        }
        
        return pow(x,n);
    }
    
    public static double pow(double x, int n) {
        if(n == 0) {
            return 1;
        }
        if(n == 1) {
            return x;
        }
        
        if(n%2 == 0) {
            double y = pow(x, n/2);
            return y * y;
        }
        else{
            double y = pow(x, (n-1)/2);
            return y * y * x;
        }
    }

修改后
public static void main(String[] args) {
        double x = 2;
        int n = -2147483648;
        System.out.println(myPow2(x,n));
    }
public static double myPow2(double x, int n) {
        if (n == 0) {
            return (double) 1;
        }
        
        if (n == 1) {
            return x;
        } else if (n == -1) {
            return 1 / x;
        }
        
        if ((n % 2) == 0) {
            double r = myPow(x, n / 2);
            return r * r;
        } else {
            double r = myPow(x, n / 2);
            return r * r * (n > 0 ? x : 1 / x);
        }
        
    }

GO语言版本实现：

func myPow(x float64, n int) float64 {
    if n < 0 {
        x = 1 / x
        n = -n
    }
    var pow float64 = 1
    for n > 0 {
        if n&1 == 1 {
            pow *= x
        }
        x *= x
        n >>= 1
    }
    return pow
}