如何不使用静态变量实现递归交换数组中的交替元素？

静态变量的问题在于它会保留跨调用的状态，不仅线程不安全，多次调用同一个函数还会导致逻辑混乱。用参数传递当前处理位置的方式就能彻底避免这个问题，下面是具体实现：

基于vector的实现 #

#include <iostream>
#include <vector>
#include <algorithm> // 用于std::swap

// 递归核心函数：通过index参数跟踪当前处理位置
void swapAlternateRecursive(std::vector<int>& arr, int index, int length) {
    // 终止条件：当前索引后没有可交换的元素
    if (index >= length - 1) {
        return;
    }
    // 交换当前元素与下一个元素
    std::swap(arr[index], arr[index + 1]);
    // 递归处理下一组元素（跳过已交换的两个）
    swapAlternateRecursive(arr, index + 2, length);
}

// 对外暴露的简洁接口，无需用户关心递归细节
void swapAlternate(std::vector<int>& arr) {
    swapAlternateRecursive(arr, 0, arr.size());
}

int main() {
    std::vector<int> arr = {1,2,3,4,5};
    swapAlternate(arr);
    for (int num : arr) {
        std::cout << num << " ";
    }
    // 输出结果：2 1 4 3 5
    return 0;
}

基于普通数组的实现 #

如果用C风格数组，逻辑完全一致，只是参数形式不同：

#include <iostream>
#include <algorithm>

void swapAlternateRecursive(int arr[], int index, int length) {
    if (index >= length - 1) {
        return;
    }
    std::swap(arr[index], arr[index + 1]);
    swapAlternateRecursive(arr, index + 2, length);
}

void swapAlternate(int arr[], int length) {
    swapAlternateRecursive(arr, 0, length);
}

int main() {
    int arr[] = {1,2,3,4,5};
    int length = sizeof(arr)/sizeof(arr[0]);
    swapAlternate(arr, length);
    for (int i = 0; i < length; ++i) {
        std::cout << arr[i] << " ";
    }
    return 0;
}

关键逻辑说明 #

• 递归函数通过index参数记录当前要处理的起始位置，每次交换后将索引+2，处理下一对元素
• 终止条件判断index >= length - 1：确保当前索引后还有元素可以交换，避免越界
• 这种方式完全没有依赖静态变量，每次递归调用的状态都通过参数传递，多次调用、多线程场景下都能正常工作

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