深入讲解JavaScript手写数组倒序算法,涵盖双指针法与单循环折半交换的数学原理、执行推导、完整代码实现、原地反转与不可变封装对比及边界条件处理。
手写JS数组倒序算法:双指针法与循环交换代码实现
时间:2026-11-17
浏览:568
文章目录
一、倒序算法的对称数学原理与交换模型
在不借助内置 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),无需进行任何操作,天然处于最终正确位置。
理解了对称映射原理后,读者通常会面临两种具体的代码实现思路:一种是用两个指针变量分别从首尾向中间靠近(双指针法),另一种是用单个循环变量配合数学表达式计算对称位置(单循环折半法)。下面分别讲解这两种方案的具体代码与执行细节。
二、方案一:经典双指针法(Two Pointers)代码实现
双指针法是计算机算法中最经典的解法之一。它的逻辑直观清晰,完全模拟了“两只手从数组两头向中间靠拢并对调元素”的物理动作。
1. 算法执行步骤
- 初始化左指针
left = 0,指向数组第一个元素;右指针right = array.length - 1,指向数组最后一个元素。 - 进入循环,循环条件为
left < right。当两指针相遇(奇数长度)或交叉(偶数长度)时,表示所有对称对已经交换完毕。 - 在每次循环中,交换
array[left]与array[right]的值。 - 左指针右移一步(
left++),右指针左移一步(right--)。 - 循环终止,返回修改后的原数组。
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. 算法执行步骤
- 获取数组长度
const len = arr.length。 - 计算循环终止边界
const mid = Math.floor(len / 2)。 - 启动单变量循环
for (let i = 0; i < mid; i++)。 - 在每一次循环中,当前左侧索引为
i,计算出其对称右侧索引const targetIndex = len - 1 - i。 - 交换
arr[i]与arr[targetIndex]。
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++ 加速 |
在实际工程实践中,如果目标是编写生产环境业务逻辑,优先采用原生 arr.reverse() 或 ES2023 新增的不可变方法 arr.toReversed();而在面试考核、理解底层数据结构排列、或在无原生 API 支撑的特殊环境(如嵌入式 JS 引擎或自定义类数组数据结构)中,掌握双指针首尾相向对调则是最清晰、通用且不易出错的核心算法。
实用工具推荐
绿化、压缩、噪点和虚拟水印,自由调节做旧程度。
选择画质和输出格式,预览压缩前后的大小。