使用递归对数组进行反转操作

1. 问题描述

给定一个整数数组 arr，要求使用递归 的方式对数组进行反转操作。变量的初始值为 startingIndex = 0，表示交换操作从数组的第一个元素开始。

测试用例 1：

• 输入：起始索引 = 0，arr = [1, 2, 3, 4, 5]
• 预期输出：[5, 4, 3, 2, 1]

2. 解题思路

递归反转数组的核心思想是：每次递归交换首尾两个元素，然后缩小问题规模。

具体步骤如下：

1. 定义递归函数 reverseArray(arr, start, end)，其中 start 表示当前要交换的左边界索引，end 表示右边界索引。
2. 递归的终止条件：当 start >= end 时，说明所有元素已经交换完毕，停止递归。
3. 交换 arr[start] 和 arr[end]。
4. 递归调用 reverseArray(arr, start + 1, end - 1)，继续处理剩余部分。

3. 代码实现

3.1 Java 实现

public class ArrayReversal {

    // 递归反转数组
    public static void reverseArray(int[] arr, int start, int end) {
        // 终止条件：左边界 >= 右边界时停止
        if (start >= end) {
            return;
        }

        // 交换首尾元素
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;

        // 递归处理剩余部分
        reverseArray(arr, start + 1, end - 1);
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int startingIndex = 0; // 起始索引为 0

        // 调用递归反转
        reverseArray(arr, startingIndex, arr.length - 1);

        // 输出结果
        System.out.print("反转后的数组：[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i < arr.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]");
    }
}

运行结果：

反转后的数组：[5, 4, 3, 2, 1]

3.2 Java 实现（简化版）

public class ArrayReversal {

    // 递归反转数组
    public static void reverseArray(int[] arr, int start, int end) {
        // 终止条件：左边界 >= 右边界时停止
        if (start >= end) {
            return;
        }

        // 交换首尾元素
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;

        // 递归处理剩余部分
        reverseArray(arr, start + 1, end - 1);
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int startingIndex = 0; // 起始索引为 0

        // 调用递归反转
        reverseArray(arr, startingIndex, arr.length - 1);

        // 输出结果
        System.out.print("反转后的数组：[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i < arr.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]");
    }
}

运行结果：

反转后的数组：[5, 4, 3, 2, 1]

4. 递归过程图解

以 arr = [1, 2, 3, 4, 5] 为例，递归调用过程如下：

递归层级	start	end	交换前数组	交换后数组
第 1 层	0	4	1, 2, 3, 4, 5	5, 2, 3, 4, 1
第 2 层	1	3	5, 2, 3, 4, 1	5, 4, 3, 2, 1
第 3 层	2	2	5, 4, 3, 2, 1	终止（start >= end）

5. 复杂度分析

• 时间复杂度： O(n)，其中 n 为数组长度。每个元素最多被交换一次，递归调用 n/2 次。
• 空间复杂度： O(n)，递归调用栈的深度为 n/2，因此空间复杂度为 O(n)。

6. 总结

使用递归反转数组的关键在于：

1. 明确终止条件 ：start >= end 时停止递归。
2. 缩小问题规模 ：每次交换首尾元素后，将区间缩小为 [start + 1, end - 1]。
3. 初始值 ：startingIndex = 0 表示从数组第一个元素开始交换。

递归反转数组虽然直观，但由于空间复杂度为 O(n)，在处理超大数组时可能不如双指针迭代法高效。不过作为递归思想的经典练习，它非常适合帮助理解递归的「递推 + 回归」过程。