344.反转字符串

双指针-相向

/**
 * @param {character[]} s
 * @return {void} Do not return anything, modify s in-place instead.
 */
var reverseString = function(s) {
    let left = 0, right = s.length - 1;
    while (left < right) {
        let temp = "";
        temp = s[left];
        s[left] = s[right];
        s[right] = temp;
        left++;
        right--;
    }
    return s;

};

还可以尝试一下es6的直接交换语法

541. 反转字符串 II

不容易想到，且细节很多很多

s字符串要处理成数组！！！

i += 2 * k

/**
 * @param {string} s
 * @param {number} k
 * @return {string}
 */
var reverseStr = function(s, k) {

    // 左闭右闭
    const reverse = function(s, start, end) {
        while (start < end) {
            let temp = "";
            temp = s[start];
            s[start] = s[end];
            s[end] = temp;
            start++;
            end--;
        }
        return s;
    }

    s = s.split("");

    for(let i = 0; i < s.length; i += 2 * k) {
        // 还够一个k
        if (i + k <= s.length) {
            reverse(s, i, i + k - 1);
        } else {
            reverse(s, i, s.length - 1)
        }
    }
    s = s.join("");
    return s;

};

151. 反转字符串中的单词

双指针-快慢

确实很难，由一个一个小步骤组合而成

/**
 * @param {string} s
 * @return {string}
 */
var reverseWords = function(s) {

    // 移除多余空格函数
    const removeExtraSpaces = function (strArr) {
        let slow = 0, fast = 0;
        // 是否需要加空格
        let need = false;

        // 处理中间空格
        for (; fast < strArr.length; fast++) {
            // 不是空格, 需要处理，slow = fast; 是空格，不处理，fast继续往前跑
            if (strArr[fast] != " ") {
                strArr[slow] = strArr[fast];
                slow++;
                need = true;
                continue;
            }
            if (need) {
                strArr[slow] = " ";
                slow++;
                need = false;
            }
        }

        // 处理尾部多余空格
        if (strArr[slow - 1] === " ") {
            // 是空格，则删除，长度减少1
            strArr.length = slow - 1;
            // 不是空格，长度就是slow;
        } else {
            strArr.length = slow;
        }

        return strArr;
    }
    // 翻转函数
    const reverse = function (strArr, start, end) {
        let temp = " ";
        while (start < end) {
            temp = strArr[start];
            strArr[start] = strArr[end];
            strArr[end] = temp;
            start++;
            end--
        }
        return strArr;
    }

    // 正式开始处理
    let resArr = Array.from(s);
    // 1.移除多余空格
    resArr = removeExtraSpaces(resArr);
    // 2.整体翻转
    resArr = reverse(resArr, 0, resArr.length - 1);
    // 3.翻转单个单词(遇到空格或最后一个单词后面，翻转空格前的单词)
    let start = 0;
    for (let i = 0; i <= resArr.length; i++) {
        if (resArr[i] === " " || i === resArr.length) {
            resArr = reverse(resArr, start, i - 1);
            // 下一轮用
            start = i + 1;
        }
    }

    // 4.重组数组
    s = resArr.join(""); 

    return s;

};

替换数字

其实很多数组填充类的问题，其做法都是先预先给数组扩容带填充后的大小，然后在从后向前进行操作。