编写一个递归程序求解一组数中前两个最大数，要求最多使用O(nlog2n)次递归调用。

编写一个递归程序求解一组数中前两个最大数，并限制在O(nlog2n)的时间复杂度内，通常需要借助分治策略。我们可以设计一个两路归并排序的思想，同时记录下每个阶段的最大值和第二大的值。以下是Python的一个例子：

def merge_sort(arr):
    if len(arr) <= 1:
        return arr, arr[0], None

    mid = len(arr) // 2
    left_half, max_left, second_max_left = merge_sort(arr[:mid])
    right_half, max_right, second_max_right = merge_sort(arr[mid:])

    merged = []
    i = j = k = 0

    while i < len(left_half) and j < len(right_half):
        if left_half[i] > right_half[j]:
            merged.append(left_half[i])
            if max_left == left_half[i]:
                second_max_left = left_half[k]
            else:
                second_max_left = max(second_max_left, left_half[k])
            i += 1
        elif left_half[i] <= right_half[j]:
            merged.append(right_half[j])
            if max_right == right_half[j]:
                second_max_right = right_half[k]
            else:
                second_max_right = max(second_max_right, right_half[k])
            j += 1
        k += 1

    # 如果左半部分还有剩余元素
    while i < len(left_half):
        merged.append(left_half[i])
        if max_left == left_half[i]:
            second_max_left = left_half[k]
        else:
            second_max_left = max(second_max_left, left_half[k])
        i += 1

    # 如果右半部分还有剩余元素
    while j < len(right_half):
        merged.append(right_half[j])
        if max_right == right_half[j]:
            second_max_right = right_half[k]
        else:
            second_max_right = max(second_max_right, right_half[k])
        j += 1

    # 返回合并后的数组以及前两个最大数
    return merged, max(max_left, max_right), max(second_max_left, second_max_right)

# 示例
arr = [4, 2, 9, 6, 5, 7]
sorted_arr, first_max, second_max = merge_sort(arr)
print(f"前两个最大数是 {first_max} 和 {second_max}")

在这个递归函数中，每次分割数组都消耗O(log n)的时间，而合并的过程可以认为是常数时间操作。因此，总的时间复杂度是O(n log n)。