递归算法之快速幂（Exponentiation by Squaring）详细解读

Katie。

于 2024-10-24 08:00:00 发布

阅读量1.2k

点赞数 19

分类专栏：算法分析文章标签：算法

本文链接：https://blog.csdn.net/m0_61840987/article/details/143139140

版权

算法分析专栏收录该内容

87 篇文章

订阅专栏

快速幂（Exponentiation by Squaring）是一种用于快速计算大整数的幂次的算法。传统的幂运算需要进行 nnn 次乘法，而快速幂通过将幂次指数二分，减少了所需的乘法次数，使得计算复杂度从 O(n) 降低到 O(log⁡n)。它广泛应用于大整数运算、模幂运算（尤其是在密码学领域），以及其他需要高效幂运算的地方。

1. 基本思想

快速幂的基本思想是利用指数的二进制性质，将大规模的幂运算转化为多个小规模的幂运算。通过将指数的幂次按二分递归或迭代来处理，可以有效减少运算次数。

对于给定的底数 x 和幂次 n，我们希望计算的值。使用以下规则来递归地进行幂运算：

若 n 为偶数，则：

若 n 为奇数，则：

通过上述方法，每次将指数 n 减半，最终使得幂次计算变得更加高效。

2. 算法过程

快速幂算法有两种实现方式：递归和迭代。两者的思路基本一致，但实现方式不同。

2.1 递归实现

递归实现利用了函数调用栈，在每次递归调用时将问题规模减半，最终返回结果。

递归实现的代码：

public class FastPower {

    // 递归实现的快速幂
    public static long fastPower(long x, long n) {
        if (n == 0) {
            return 1;  // 任何数的0次幂为1
        }

        long half = fastPower(x, n / 2);  // 计算 x^(n/2)
        
        if (n % 2 == 0) {
            return half * half;  // 如果n是偶数，结果是 half^2
        } else {
            return half * half * x;  // 如果n是奇数，结果是 half^2 * x
        }
    }

    public static void main(String[] args) {
        long base = 2;
        long exponent = 10;
        long result = fastPower(base, exponent);
        System.out.println(base + "^" + exponent + " = " + result);  // 输出 2^10 = 1024
    }
}

代码解析：

当幂次 n=0 时，直接返回 1，这是幂运算的基础情况。
通过递归调用 fastPower(x, n / 2)，将幂次 n 不断减半。
根据 n 的奇偶性，选择是否乘以额外的底数 x。
每次递归调用使得问题规模减半，最终的递归深度为 O(log⁡n)。

2.2 迭代实现

迭代实现不使用递归，而是通过循环迭代来完成幂运算，避免了递归带来的函数调用开销。

迭代实现的代码：

public class FastPowerIterative {

    // 迭代实现的快速幂
    public static long fastPowerIterative(long x, long n) {
        long result = 1;  // 初始化结果为1
        long base = x;  // 将底数存储在base中
        while (n > 0) {
            if (n % 2 == 1) {  // 如果n是奇数
                result *= base;  // 乘上当前的base
            }
            base *= base;  // 每次将base平方
            n /= 2;  // 幂次减半
        }
        return result;
    }

    public static void main(String[] args) {
        long base = 2;
        long exponent = 10;
        long result = fastPowerIterative(base, exponent);
        System.out.println(base + "^" + exponent + " = " + result);  // 输出 2^10 = 1024
    }
}

代码解析：

初始时，result 被设为 1，表示幂运算的累积结果。
base 保存当前的底数，初始值为 xxx。
每次判断指数 nnn 的奇偶性，若为奇数，将当前的底数 basebasebase 累乘到结果 result 中。
无论指数是否为奇数，每次都将底数平方，并将指数减半。
迭代完成后，最终结果保存在 result 中。

3. 快速幂的时间复杂度

快速幂将指数 n 不断二分，问题规模减小得非常快。每次运算的成本为常数时间，因此其时间复杂度为 O(\log n)，相比于直接的幂运算 O(n) 效率大大提高。

时间复杂度：O(log⁡n)
空间复杂度：
- 递归版本的空间复杂度为 O(log⁡n)（递归深度）。
- 迭代版本的空间复杂度为 O(1)（常数额外空间）。

4. 模幂运算

快速幂常常用于处理 模幂运算，即计算。在许多应用中，幂运算的结果可能非常大，无法直接存储，因此需要对结果取模。例如，密码学中的 RSA 算法就需要大量的模幂运算。

在快速幂的基础上，我们可以通过在每次乘法运算后取模来确保结果不会溢出。

模幂运算的实现：

public class ModularExponentiation {

    // 快速幂的模运算实现
    public static long modPower(long x, long n, long mod) {
        long result = 1;
        long base = x % mod;  // 先对base取模
        
        while (n > 0) {
            if (n % 2 == 1) {
                result = (result * base) % mod;  // 累积结果后取模
            }
            base = (base * base) % mod;  // 将base平方后取模
            n /= 2;
        }
        return result;
    }

    public static void main(String[] args) {
        long base = 2;
        long exponent = 10;
        long mod = 1000;
        long result = modPower(base, exponent, mod);
        System.out.println(base + "^" + exponent + " % " + mod + " = " + result);  // 输出 2^10 % 1000 = 24
    }
}