从数组求解极差：将迭代算法改写为递归版本

没问题，我来帮你把这个迭代的数组极差求解算法改成递归版本。咱们先对齐一下原始的迭代逻辑，再一步步转成递归实现。

首先，先把你描述的迭代算法用代码写出来（以Python为例），方便对照：

def calculate_range_iterative(A):
    n = len(A)
    if n == 0:
        return 0  # 处理空数组的边界情况
    min_val = float('inf')
    max_val = float('-inf')
    for i in range(n):
        if A[i] > max_val:
            max_val = A[i]
        if A[i] < min_val:
            min_val = A[i]
    return max_val - min_val

这个迭代逻辑的核心是逐个遍历数组元素，维护当前的最小和最大值，递归版本我们可以完全贴合这个思路，把遍历过程改成递归调用：

递归实现版本（贴近原迭代逻辑） #

def calculate_range_recursive(A):
    # 内部辅助递归函数，负责遍历数组并维护当前的min/max
    def recursive_helper(current_index, current_min, current_max):
        # 递归终止条件：所有元素都处理完了
        if current_index == len(A):
            return current_max - current_min
        
        # 处理当前元素，更新min和max
        current_num = A[current_index]
        updated_min = min(current_min, current_num)
        updated_max = max(current_max, current_num)
        
        # 递归处理下一个元素
        return recursive_helper(current_index + 1, updated_min, updated_max)
    
    # 边界情况：空数组直接返回0
    if not A:
        return 0
    
    # 初始化调用：从第0个元素开始，初始min为无穷大，max为负无穷大（和原迭代一致）
    return recursive_helper(0, float('inf'), float('-inf'))

递归逻辑解释 #

• 我们用了一个内部的recursive_helper函数来做实际的递归工作，它接收三个参数：current_index（当前要处理的元素下标）、current_min（遍历到当前位置的最小值）、current_max（遍历到当前位置的最大值）。
• 终止条件：当current_index等于数组长度时，说明所有元素都处理完毕，直接返回当前max和min的差值。
• 递归步骤：每次处理当前下标对应的元素，更新min和max，然后递归调用自身处理下一个下标（current_index + 1），把更新后的min和max传进去。
• 主函数先处理空数组的边界情况，然后以初始下标0、初始min为无穷大、初始max为负无穷大的参数调用辅助函数，和原迭代的初始化逻辑完全匹配。

另一种分治式递归实现（拓展思路） #

如果你想尝试分治风格的递归（把数组拆成两半分别处理，再合并结果），也可以这样写：

def calculate_range_divide_conquer(A):
    if not A:
        return 0
    if len(A) == 1:
        return 0  # 单个元素的极差为0
    
    # 把数组分成左右两部分
    mid = len(A) // 2
    left_part = A[:mid]
    right_part = A[mid:]
    
    # 递归求解左右两部分的min和max
    left_min = min(left_part)
    left_max = max(left_part)
    right_min = min(right_part)
    right_max = max(right_part)
    
    # 合并得到全局的min和max
    global_min = min(left_min, right_min)
    global_max = max(left_max, right_max)
    
    return global_max - global_min

不过这个版本和你原始的迭代遍历逻辑差异较大，更适合理解分治递归的思路。

内容的提问来源于stack exchange，提问作者Pickslides