JavaScript数组原地反转：深入理解与多种实现方法

/**
 * @param {character[]} s
 * @return {void} Do not return anything, modify s in-place instead.
 */
var reverseStringIncorrect = function (s) {
    let arr = []; // 创建了一个新数组
    for (let i = s.length - 1; i >= 0; i--) {
        arr.push(s[i]); // 将原始数组的元素倒序推入新数组
    }
    return arr; // 返回新数组，原始数组 s 未被修改
};

const original = ["h", "e", "l", "l", "o"];
reverseStringIncorrect(original);
console.log(original); // 输出: ["h", "e", "l", "l", "o"] - 原始数组未变

/**
 * @param {character[]} s
 * @return {void} Do not return anything, modify s in-place instead.
 */
var reverseStringPartialCorrect = function (s) {
    let reversed = []; // 创建一个新数组
    for (let i = s.length - 1; i >= 0; i--) {
        reversed.push(s[i]); // 倒序填充新数组
    }

    // 第二个循环：将新数组的内容复制回原始数组
    for (let i = 0; i < s.length; i++) {
        s[i] = reversed[i]; // 这部分实现了原地修改
    }

    return reversed; // 然而，函数仍然返回了新数组，而不是 void
};

const original2 = ["h", "e", "l", "l", "o"];
reverseStringPartialCorrect(original2);
console.log(original2); // 输出: ["o", "l", "l", "e", "h"] - 原始数组被修改了

/**
 * @param {character[]} s
 * @return {void} Do not return anything, modify s in-place instead.
 */
var reverseStringWithBuiltIn = function (s) {
    s.reverse(); // 直接调用内置方法进行原地反转
    // 函数不需要显式返回任何值
};

const testcase1 = ['h', 'e', 'l', 'l', 'o'];
console.log('Original:', testcase1); // 输出: Original: ["h", "e", "l", "l", "o"]
reverseStringWithBuiltIn(testcase1);
console.log('Modified:', testcase1); // 输出: Modified: ["o", "l", "l", "e", "h"]

const testcase2 = ['1', '2', '3'];
console.log('Original:', testcase2); // 输出: Original: ["1", "2", "3"]
reverseStringWithBuiltIn(testcase2);
console.log('Modified:', testcase2); // 输出: Modified: ["3", "2", "1"]

/**
 * @param {character[]} s
 * @return {void} Do not return anything, modify s in-place instead.
 */
var reverseStringManual = function (s) {
    const length = s.length;
    // 循环到数组的中间位置即可，Math.floor(length / 2) 确保奇数长度数组中间元素不被重复交换
    for (let i = 0; i < Math.floor(length / 2); i++) {
        // 使用ES6的解构赋值进行元素交换
        // s[i] 与 s[length - 1 - i] 互换
        [s[i], s[length - 1 - i]] = [s[length - 1 - i], s[i]];
    }
};

const testcaseOdd = ['1', '2', '3'];
console.log('Original (Odd):', testcaseOdd); // 输出: Original (Odd): ["1", "2", "3"]
reverseStringManual(testcaseOdd);
console.log('Modified (Odd):', testcaseOdd); // 输出: Modified (Odd): ["3", "2", "1"]

const testcaseEven = ['a', 'b', 'c', 'd'];
console.log('Original (Even):', testcaseEven); // 输出: Original (Even): ["a", "b", "c", "d"]
reverseStringManual(testcaseEven);
console.log('Modified (Even):', testcaseEven); // 输出: Modified (Even): ["d", "c", "b", "a"]

const originalArray = ['a', 'b', 'c'];
const reversedCopy = originalArray.toReversed();

console.log('Original Array:', originalArray); // 输出: Original Array: ["a", "b", "c"] (未改变)
console.log('Reversed Copy:', reversedCopy);   // 输出: Reversed Copy: ["c", "b", "a"] (新数组)