手写JS数组倒序算法:双指针法与循环交换代码实现

作者:闭包旅人时间:2026-11-17 10:04:36浏览:567

深入讲解JavaScript手写数组倒序算法,涵盖双指针法与单循环折半交换的数学原理、执行推导、完整代码实现、原地反转与不可变封装对比及边界条件处理。

手写JS数组倒序算法:双指针法与循环交换代码实现
文章缩略图:JS 数组倒序的核心流程与双指针对称交换逻辑
在 JavaScript 开发中,数组倒序的底层逻辑是对称位置元素的相互交换。手写实现的核心在于通过索引准确定位数组首尾两侧的对应元素,并向数组中心推进交换,整个过程只需要遍历数组长度的一半。最经典的两种手写实现方式为双指针相向移动法与单循环折半索引法。本文将详细讲解这两种算法的数学原理、执行过程推导、完整代码实现,并分析原地修改与纯函数不可变封装的实际应用场景与边界处理。

一、倒序算法的对称数学原理与交换模型

在不借助内置 Array.prototype.reverse() 方法的前提下,如果要求自己手写算法将数组元素颠倒排列,首先需要理解倒序操作的数学本质。对于一个长度为 n 的连续数组,倒序后原本位于索引 0 的元素将移到 n - 1,索引 1 的元素移到 n - 2。以此类推,对于任意索引 i,与其互换的目标索引恒为:

targetIndex = length - 1 - i

基于这个对称关系,整个倒序过程只需要交换 Math.floor(n / 2) 次。无论数组长度是奇数还是偶数,这一规律都完全成立:

  • 偶数长度(例如 length = 6): 数组包含 3 对完美对称的元素(索引 0 与 5、1 与 4、2 与 3)。完成 3 次对调后,所有元素位置颠倒,中间没有孤立元素。
  • 奇数长度(例如 length = 5): 数组两端有 2 对对称元素(索引 0 与 4、1 与 3),而位于正中间的索引 2 对应自身(5 - 1 - 2 = 2),无需进行任何操作,天然处于最终正确位置。
手写JS数组倒序算法:双指针法与循环交换代码实现
图 1:数组倒序的几何对称模型与奇偶长度中心轴对比

理解了对称映射原理后,读者通常会面临两种具体的代码实现思路:一种是用两个指针变量分别从首尾向中间靠近(双指针法),另一种是用单个循环变量配合数学表达式计算对称位置(单循环折半法)。下面分别讲解这两种方案的具体代码与执行细节。

二、方案一:经典双指针法(Two Pointers)代码实现

双指针法是计算机算法中最经典的解法之一。它的逻辑直观清晰,完全模拟了“两只手从数组两头向中间靠拢并对调元素”的物理动作。

1. 算法执行步骤

  1. 初始化左指针 left = 0,指向数组第一个元素;右指针 right = array.length - 1,指向数组最后一个元素。
  2. 进入循环,循环条件为 left < right。当两指针相遇(奇数长度)或交叉(偶数长度)时,表示所有对称对已经交换完毕。
  3. 在每次循环中,交换 array[left] 与 array[right] 的值。
  4. 左指针右移一步(left++),右指针左移一步(right--)。
  5. 循环终止,返回修改后的原数组。
手写JS数组倒序算法:双指针法与循环交换代码实现
图 2:双指针相向移动与元素对调执行推导(4 元素完整追踪过程)

2. 完整 JavaScript 代码实现

在元素交换的具体写法上,可以使用经典的临时变量暂存法,也可以使用 ES6 的解构赋值语法。在生产环境或性能敏感的算法中,推荐使用临时变量,因为它的执行效率高、无额外语法开销;而在追求简洁的代码中,解构赋值写法更为优雅。

/**
 * 双指针法原地倒序数组(临时变量写法,性能最高)
 * @param {Array} arr - 需要倒序的数组
 * @returns {Array} 倒序后的原数组引用
 */
function reverseArrayByTwoPointers(arr) {
  // 防御性校验:若不是有效数组则直接返回
  if (!Array.isArray(arr) || arr.length <= 1) {
    return arr;
  }

  let left = 0;
  let right = arr.length - 1;

  while (left < right) {
    // 步骤一:通过临时变量暂存并交换两端元素
    const temp = arr[left];
    arr[left] = arr[right];
    arr[right] = temp;

    // 步骤二:指针相向移动
    left++;
    right--;
  }

  return arr;
}

// 执行测试示例
const sample1 = [10, 20, 30, 40, 50];
console.log("双指针倒序结果:", reverseArrayByTwoPointers(sample1));
// 示例输出:[ 50, 40, 30, 20, 10 ]

const sample2 = ["A", "B", "C", "D"];
console.log("偶数长度测试:", reverseArrayByTwoPointers(sample2));
// 示例输出:[ 'D', 'C', 'B', 'A' ]
细节提醒:为什么循环条件是 left < right 而非 left <= right?
当数组长度为奇数时,指针最终会在正中间索引相遇(例如 left === 2 && right === 2)。此时该元素无需与自身交换。写成 left < right 可以精确跳过这一次无意义的自赋值操作,逻辑更加严密。

三、方案二:单循环折半索引交换法

双指针法需要维护两个独立的索引变量。而在某些场景下,读者可能更希望使用标准的 for 循环,仅维护一个自增计数器。这就是单循环折半法。

1. 算法执行步骤

  1. 获取数组长度 const len = arr.length。
  2. 计算循环终止边界 const mid = Math.floor(len / 2)。
  3. 启动单变量循环 for (let i = 0; i < mid; i++)。
  4. 在每一次循环中,当前左侧索引为 i,计算出其对称右侧索引 const targetIndex = len - 1 - i。
  5. 交换 arr[i] 与 arr[targetIndex]。
手写JS数组倒序算法:双指针法与循环交换代码实现
图 3:单循环折半机制与边界条件“二次翻转”陷阱对照

2. 警惕“二次翻转”逻辑陷阱

初学者在手写循环交换时,最容易犯的一个严重错误是将循环条件误写为 i < arr.length。

正如上图所示,当 i 处于前半段(0 到 mid - 1)时,数组被成功倒序;但当循环越过中点进入后半段时,i 再次与对应位置交换,实际上把已经对调好的元素重新对调回了原位。最终执行完毕后,数组不仅没有被倒序,反而恢复成了原样。因此,循环上限必须严格限制在 Math.floor(len / 2)。

3. 完整 JavaScript 代码实现

/**
 * 单循环折半索引交换法(ES6解构赋值写法)
 * @param {Array} arr - 需要倒序的数组
 * @returns {Array} 倒序后的原数组引用
 */
function reverseArrayByHalfLoop(arr) {
  if (!Array.isArray(arr) || arr.length <= 1) {
    return arr;
  }

  const len = arr.length;
  const mid = Math.floor(len / 2);

  for (let i = 0; i < mid; i++) {
    const targetIndex = len - 1 - i;
    // 使用 ES6 解构语法完成单行对调
    [arr[i], arr[targetIndex]] = [arr[targetIndex], arr[i]];
  }

  return arr;
}

// 执行测试示例
const numbers = [1, 2, 3, 4, 5, 6];
console.log("折半循环倒序结果:", reverseArrayByHalfLoop(numbers));
// 示例输出:[ 6, 5, 4, 3, 2, 1 ]

四、原地修改(In-place)与不可变纯函数封装

上述双指针法与折半单循环法均属于原地算法(In-place Algorithm)。原地算法的优势是空间复杂度仅为 O(1),无需额外开辟新的数组内存,适用于数据量庞大或内存受限的环境。

然而在现代前端开发(如 React、Vue 或 Redux 状态管理)中,直接修改传入的原数组会产生强烈的副作用(Side Effect),导致组件无法感知状态变化或引发意外的数据污染。因此,在日常业务开发中,通常需要将倒序算法封装为纯函数(Pure Function)。

纯函数版本的代码实现

/**
 * 纯函数版数组倒序:不修改原数组,返回全新倒序数组
 * @param {Array} arr - 原始输入数组
 * @returns {Array} 全新的倒序数组副本
 */
function toReversedArray(arr) {
  if (!Array.isArray(arr)) {
    throw new TypeError("参数必须为一个有效的 JavaScript 数组");
  }
  // 浅拷贝原始数组,隔离内存引用
  const copy = [...arr];
  return reverseArrayByTwoPointers(copy);
}

// 验证原数组是否被保护
const originList = ["apple", "banana", "cherry"];
const reversedList = toReversedArray(originList);

console.log("新数组:", reversedList);
// 示例输出:[ 'cherry', 'banana', 'apple' ]

console.log("原数组保持未修改:", originList);
// 示例输出:[ 'apple', 'banana', 'cherry' ]
console.log("引用隔离验证:", originList !== reversedList);
// 示例输出:true

五、边界条件与异常防御

手写算法在面试和工程落地中,鲁棒性(Robustness)是核心考察标准。以下三种边界情况在编码时必须予以关注:

  • 空数组 [] 与单元素数组 [x]: 此时 arr.length <= 1。无论是双指针(left = 0, right = 0 或 right = -1)还是折半循环(mid = 0),循环体都不会被执行,安全直接返回原数组。
  • 非数组非法入参: 若传入 null、undefined 或普通对象,直接访问 .length 或索引操作可能会抛出未捕获异常。应在函数入口处添加 Array.isArray(arr) 的防御性检查。
  • 稀疏数组(Sparse Array): 若数组中包含空槽(例如 new Array(3) 或 [1, , 3]),在执行元素互换时,undefined 或空槽属性会被对应交换,手写的显式索引赋值会将稀疏槽转换为显式属性。

六、算法多维对比与技术选型总结

综合对比手写双指针法、单循环折半法、以及原生 API,可以得出以下性能与选型结论:

方案名称 时间复杂度 空间复杂度 是否修改原数组 典型适用场景
双指针相向法 O(n) O(1) 是 (原地) 算法面试考查、底层数据结构封装、高性能原地操作
单循环折半法 O(n) O(1) 是 (原地) 单计数器循环场景、紧凑代码编写
纯函数浅拷贝倒序 O(n) O(n) 否 (纯函数) React/Vue 状态更新、前端不可变数据流操作
原生 reverse() O(n) O(1) 是 (原地) 日常生产代码直接调用,引擎底层 C++ 加速
手写JS数组倒序算法:双指针法与循环交换代码实现
图 4:JavaScript 数组倒序技术方案全景对比与技术选型决策树

在实际工程实践中,如果目标是编写生产环境业务逻辑,优先采用原生 arr.reverse() 或 ES2023 新增的不可变方法 arr.toReversed();而在面试考核、理解底层数据结构排列、或在无原生 API 支撑的特殊环境(如嵌入式 JS 引擎或自定义类数组数据结构)中,掌握双指针首尾相向对调则是最清晰、通用且不易出错的核心算法。

作者最新文章
相关文章
更多