剑指offer12--数值的整数次方

题目描述

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

保证base和exponent不同时为0

思路

机试直接调用pow库函数

#include<cmath>
return pow(base,exponent);

面试就好好写
思路1：暴力求解
注意底数是0返回0，指数是0返回1，负底数按正底数返回再取倒

实现

class Solution {
public:
    double Power(double base, int exponent) {
        if (base==0) return 0;
        if (exponent==0) return 1;
        if (exponent==1) return base;
        double ret=1;
        if (exponent>0)
        {
            while(exponent!=0)
            {
                ret*=base;
                exponent--;
            }
        }
        else
        {
            ret=1/Power(base,exponent*(-1));//变正后递归一次
        }
        return ret;
    }
};

时间复杂度为O（exponent）

思路2：递归快速幂
当指数n为偶数时，可以直接利用n/2的结果，比如当n=8时，直接取4的平方，省去了5，6，7的运算；层层递归下去；
当指数n为奇数时，需要分离一个再做偶数的运算

class Solution {
public:
    double Power(double base, int exponent) {
        if (base==0) return 0;
        if (exponent==0) return 1;
        double ret=1;
        if (exponent>0)
        {
            if (exponent&1)
            {
                exponent--;
                ret=base*Power(base,exponent/2)*Power(base,exponent/2);
            }
            else
                ret=Power(base,exponent/2)*Power(base,exponent/2);
        }
        else
            ret=1/Power(base,exponent*(-1));
        return ret;
    }
    
};

思路2：非递归快速幂
对于一个指数n来说，将其表示成2进制，例如n=9，表示成二进制为1001，即 9=1*2^3 +0 *2^2+0 * 2^1 +1 *2 ^ 0
x^9=x ^(1 * 2^3 +0 *2^2+0 * 2^1 +1 2 ^ 0)
=x ^(1 2^3 +1 *2 ^ 0)
=x ^(2 ^0)*x ^(2 ^3)

即对指数的二进制形式，遇1则将当前幂值乘进返回值

实现

class Solution {
public:
    double Power(double base, int exponent) {
        if (base==0) return 0;
        if (exponent<0)
        {
            base=1/base;
            exponent=-exponent;
        }
        double ret=1;
        while (exponent)
        {
            if (exponent&1)//检测尾部是否为1，例如9=1001与1之后为1
            {
                ret*=base;//乘进返回值
            }
            base*=base;//底数自乘
            exponent>>=1;//准备检测下一位
        }
        return ret;
    }
};

分析

思路1：时间复杂度为O（n),空间复杂度为O（1）
思路2：时间复杂度为O（logn)，空间复杂度为O（logn)，因为用到了递归，每次调用的时候需要保存上一层递归的结果
思路3：时间复杂度为O（logn)，空间复杂度为O（1)