代码随想录的第七天

344. 反转字符串

双指针：

var reverseString = function(s) {
    let left = 0,right = s.length - 1;
    while (left < right) {
        const temp = s[left]
        s[left] = s[right]
        s[right] = temp
        left++
        right--
    }
    return s
};

思路：

1、左右两个指针交换值，然后向中间靠拢

2、为什么不能left=right？等于的情况就是奇数数组，中间的不用动

541. 反转字符串 II

var reverseStr = function(s, k) {
    let arr = s.split('');
    for (let i = 0; i< arr.length; i += 2 * k) {
        let left = i
        let right = (i + k <= arr.length) ? i + k -  1 : arr.length - 1
        while (left < right) {
            const temp = arr[left]
            arr[left] = arr[right]
            arr[right] = temp
            left++
            right--
        }
    }
    return arr.join('')
};

思路：

1、首先先将字符串转换成数组，然后对数组进行操作

2、重点就是判断每次的左右的边界，可以直接循环2*k那么每次都是一个闭合的小循环，i每次就是左指针的位置，如果说i+k比数组长度上那么说明最后的不到k个值，那么右指针最多指到length-1位置，然后进行两两交换即可

剑指 Offer 05. 替换空格

// 没明白要用啥
var replaceSpace = function(s) {
    let arr = s.split(' ')
    s = arr.join('%20')
    return s
};

var replaceSpace = function(s) {
    const arr = Array.from(s)
    let count = 0

    for (let i = 0; i < arr.length; i++) {
        if (arr[i] === ' ') {
            count = count + 1
        }
    }

    let left = arr.length - 1
    let right = arr.length + count*2 - 1
    
    while (left >= 0) {
        if (arr[left] === ' ') {
            arr[right--] = '0'
            arr[right--] = '2'
            arr[right--] = '%'
            left--
        } else {
            arr[right--] = arr[left--];
        }
    }

    return arr.join('')
};

思路：

1、将字符串转换成数组，然后去记录空格的数量，左指针是数组长度，右指针是记录的空格数量*2（为什么？因为要填充三个字符，然后本身已经有了一倍的空格，再来两个就行）

2、进行遍历进行填充

151. 反转字符串中的单词

var reverseWords = function(s) {
    const arr = s.trim().split(' ').filter(item => item.trim() !== '')
    let left = 0, right = arr.length - 1
    while (left < right) {
        const temp = arr[left]
        arr[left] = arr[right]
        arr[right] = temp
        left++
        right--
    }
    return arr.join(' ')
};

不使用库函数

var reverseWords = function(s) {
    const arr = Array.from(s)
    // 删除多余空格
    remove(arr)
    // 翻转
    reverse(arr, 0, arr.length - 1);

    let start = 0;
    for (let i = 0; i <= arr.length; i++) {
        if (arr[i] === ' ' || i === arr.length) {
            reverse(arr, start, i - 1)
            start = i + 1
        }
    }
    return arr.join('')
};

function remove (arr) {
    let slow = 0,fast = 0;
    while (fast < arr.length) {
        if (arr[fast] === ' ' && (fast === 0 || arr[fast - 1] === ' ')) {
            fast++
        } else {
            arr[slow++] = arr[fast++];
        }
    }
    arr.length = arr[slow - 1] === ' ' ? slow - 1 : slow
}

function reverse(strArr, start, end) {
  let left = start;
  let right = end;

  while(left < right) {
    // 交换
    [strArr[left], strArr[right]] = [strArr[right], strArr[left]];
    left++;
    right--;
  }
}

思路：

1、先删除多余的空格

2、进行字符串的翻转

3、然后在空格处再次进行翻转完成

剑指 Offer 58 - II. 左旋转字符串

var reverseLeftWords = function(s, n) {
    let newn = n % s.length
    let arr = s.split('')
    let pushArr = arr.splice(0, newn)
    arr = arr.concat(pushArr)
    return arr.join('')
};

思路：主要是要计算最终要在字符串尾部补充的元素个数就是n % s.length

var reverseLeftWords = function(s, n) {
    const arr = s.split('')
    const newn = n % s.length
    reserve(arr, 0, arr.length - 1)
    reserve(arr, 0, arr.length - newn - 1)
    reserve(arr, arr.length - newn, arr.length - 1)
    return arr.join('')
};

function reserve (arr, left, right) {
    while (left < right) {
        [arr[left], arr[right]] = [arr[right], arr[left]]
        left++
        right--
    }
}

原字符串上进行修改的思路：思路不讲了，反正就是找到n的值为临界点进行反转