快速幂算法：原理、实现与优化技巧

1. 快速幂算法核心思想解析

快速幂算法（Binary Exponentiation）是计算幂运算的高效方法，它基于一个简单但强大的数学原理：任何整数都可以表示为二进制形式，而幂运算可以通过这种二进制表示进行分解优化。

1.1 从朴素算法到快速幂

传统计算xⁿ的方法是通过n-1次乘法：

c复制double result = 1;
for(int i=0; i<n; i++){
    result *= x;
}

这种方法的时间复杂度是O(n)，当n很大时（比如n=2³¹）效率极低。

快速幂的核心突破在于发现：

code复制xⁿ = x^(bₖ·2ᵏ + ... + b₁·2¹ + b₀·2⁰) = x^(bₖ·2ᵏ) × ... × x^(b₀·2⁰)

其中bᵢ是n的二进制表示中的各位（0或1）。

1.2 二进制分解实例

以x¹⁰为例：

code复制10的二进制 = 1010
x¹⁰ = x^(8+2) = x⁸ × x²

计算过程可以转化为：

1. x² = x × x
2. x⁴ = x² × x²
3. x⁸ = x⁴ × x⁴
4. 最终结果 = x⁸ × x²

这样只需要4次乘法（而不是10次），时间复杂度降为O(log n)。

2. 关键问题与边界处理

2.1 负指数处理

当n为负数时，xⁿ = 1/x⁻ⁿ。但直接取反可能遇到边界情况：

c复制if(n < 0) {
    x = 1/x;
    n = -n;  // 这里可能溢出！
}

2.2 INT_MIN溢出问题

当n=-2³¹（即INT_MIN）时，直接取反会导致溢出，因为2³¹超出了int的正数范围。解决方案是使用更大范围的long long类型：

c复制long long N = n;
if(N < 0) {
    x = 1/x;
    N = -N;  // 安全转换
}

2.3 精度问题注意事项

1. 浮点数比较应该使用相对误差判断而非直接==
2. 连续乘法可能导致精度损失累积
3. 对于特殊值（如x=0, n=0）需要特殊处理（0⁰在数学上未定义，但编程中通常返回1）

3. 迭代法实现详解

3.1 算法步骤拆解

1. 初始化结果result=1
2. 循环直到N=0：
   • 如果当前最低位为1（N&1）：result *= x
   • x自乘（x *= x）
   • N右移一位（N >>= 1）

3.2 计算过程可视化

以x=2, n=10为例：

3.3 完整迭代实现

c复制double myPow(double x, int n) {
    long long N = n;
    if(N < 0) {
        x = 1/x;
        N = -N;
    }
    
    double result = 1.0;
    while(N > 0) {
        if(N & 1) 
            result *= x;
        x *= x;
        N >>= 1;
    }
    return result;
}

4. 递归法实现解析

4.1 分治思想应用

递归基于公式：

code复制xⁿ = (x^(n/2))²      当n为偶数
xⁿ = (x^(n/2))² × x  当n为奇数

4.2 递归树分析

计算x¹⁰的递归过程：

code复制fastPow(2,10)
    fastPow(2,5)
        fastPow(2,2)
            fastPow(2,1)
                fastPow(2,0) return 1
            return 1² × 2 = 2
        return 2² = 4
    return 4² × 2 = 32
return 32² = 1024

4.3 完整递归实现

c复制double fastPow(double x, long long n) {
    if(n == 0) return 1;
    double half = fastPow(x, n/2);
    return n%2 == 0 ? half*half : half*half*x;
}

double myPow(double x, int n) {
    long long N = n;
    return N >= 0 ? fastPow(x, N) : 1/fastPow(x, -N);
}

5. 复杂度对比与选择建议

5.1 时间复杂度分析

两种方法都是O(log n)，因为每次都将问题规模减半。

5.2 空间复杂度对比

5.3 实际应用选择建议

1. 优先选择迭代法：
   • 无栈溢出风险
   • 空间效率更高
2. 递归法的优势：
   • 代码更简洁直观
   • 适合理解分治思想

6. 典型应用场景扩展

6.1 相关LeetCode题目

1. 判断2的幂（231题）：

c复制bool isPowerOfTwo(int n) {
    return n > 0 && (n & (n-1)) == 0;
}

2. 计算汉明重量（191题）：

c复制int hammingWeight(uint32_t n) {
    int count = 0;
    while(n) {
        n &= n-1;
        count++;
    }
    return count;
}

6.2 大数取模运算

快速幂在RSA等加密算法中有重要应用，计算(a^b) mod m：

c复制long long modPow(long long a, long long b, long long m) {
    long long res = 1;
    a %= m;
    while(b > 0) {
        if(b & 1) res = (res*a) % m;
        a = (a*a) % m;
        b >>= 1;
    }
    return res;
}

7. 优化技巧与注意事项

7.1 性能优化实践

1. 使用位运算代替除法/取模：

   • n/2 → n>>1
   • n%2 → n&1

2. 循环展开：对于已知范围的n可以手动展开部分循环

3. 使用查表法：对频繁计算的小指数预先缓存结果

7.2 常见错误排查

1. 忘记处理n=INT_MIN的情况
2. 浮点数比较使用==导致错误
3. 递归深度过大导致栈溢出
4. 整数溢出未使用long long

7.3 测试用例建议

应包括以下边界情况：

c复制x=2.0, n=0 → 1
x=1.0, n=INT_MAX → 1
x=2.0, n=INT_MIN → 0
x=0.0, n=10 → 0
x=0.0, n=-1 → INF（需特殊处理）