递归算法实战：从汉诺塔到快速幂的优化与应用

1. 汉诺塔问题：递归思维的经典启蒙

汉诺塔问题作为递归算法的入门经典，其精妙之处在于用极简的规则展现了递归思维的核心逻辑。我第一次接触这个问题是在大学算法课上，当时花了整整一周才真正理解其递归本质。

1.1 问题定义与递归解法

汉诺塔问题的标准描述是：有三根柱子A、B、C，其中A柱上有n个大小不一的圆盘，初始时所有圆盘按大小顺序叠放（大的在下，小的在上）。目标是将所有圆盘移动到C柱，移动过程中需要遵守：

1. 每次只能移动一个圆盘
2. 任何时候大盘不能压在小盘上
3. 可以借助B柱作为中转

递归解法的核心思想是：

1. 将前n-1个盘子从A移到B（借助C）
2. 将第n个盘子从A移到C
3. 将前n-1个盘子从B移到C（借助A）

python复制def hanoi(n, source, target, auxiliary):
    if n > 0:
        # 将n-1个盘子从源柱移动到辅助柱
        hanoi(n-1, source, auxiliary, target)
        # 移动第n个盘子
        print(f"Move disk {n} from {source} to {target}")
        # 将n-1个盘子从辅助柱移动到目标柱
        hanoi(n-1, auxiliary, target, source)

1.2 时间复杂度分析与优化

汉诺塔问题的时间复杂度是O(2^n)，因为每个盘子需要移动两次。对于n个盘子，最少需要2^n - 1步才能完成。这个指数级复杂度使得当n较大时（如n=64），即使在现代计算机上也需要极长时间才能完成。

实际应用中，我们常用汉诺塔问题来测试递归算法的性能。在我的开发经验中，当n>20时，普通递归实现就会开始出现明显的性能问题。

1.3 非递归实现与迭代解法

虽然递归解法直观，但在实际工程中，我们有时需要考虑非递归实现以避免栈溢出风险。汉诺塔问题的迭代解法可以利用栈来模拟递归过程：

python复制def hanoi_iterative(n, source, target, auxiliary):
    stack = []
    stack.append((n, source, target, auxiliary, False))
    
    while stack:
        current = stack.pop()
        n, src, tgt, aux, processed = current
        
        if n == 1:
            print(f"Move disk 1 from {src} to {tgt}")
        else:
            if not processed:
                stack.append((n, src, tgt, aux, True))
                stack.append((n-1, src, aux, tgt, False))
            else:
                print(f"Move disk {n} from {src} to {tgt}")
                stack.append((n-1, aux, tgt, src, False))

2. 快速幂算法：递归与迭代的双重演绎

快速幂算法（Exponentiation by squaring）是递归思想的另一个经典应用，它能将幂运算的时间复杂度从O(n)降低到O(log n)。

2.1 递归实现原理

快速幂的核心思想是利用幂的分解性质：

• 当n为偶数时，x^n = (x^(n/2))^2
• 当n为奇数时，x^n = x * (x^((n-1)/2))^2

python复制def fast_pow(x, n):
    if n == 0:
        return 1
    elif n < 0:
        return 1 / fast_pow(x, -n)
    elif n % 2 == 1:
        return x * fast_pow(x, n-1)
    else:
        half = fast_pow(x, n//2)
        return half * half

2.2 迭代实现与位运算优化

在实际应用中，迭代实现通常性能更好且不会受递归深度限制：

python复制def fast_pow_iterative(x, n):
    if n < 0:
        x = 1 / x
        n = -n
    result = 1
    while n > 0:
        if n % 2 == 1:
            result *= x
        x *= x
        n = n // 2
    return result

更进一步的优化是使用位运算代替除法：

python复制def fast_pow_bit(x, n):
    if n < 0:
        x = 1 / x
        n = -n
    result = 1
    while n:
        if n & 1:
            result *= x
        x *= x
        n >>= 1
    return result

2.3 模数情况下的快速幂

在密码学和算法竞赛中，我们经常需要计算大数的模幂。快速幂算法可以轻松扩展：

python复制def mod_pow(x, n, mod):
    result = 1
    x = x % mod
    while n > 0:
        if n % 2 == 1:
            result = (result * x) % mod
        x = (x * x) % mod
        n = n // 2