代码随想录算法训练营Day08|344.反转字符串 541. 反转字符串II 剑指Offer 05.替换空格 151.翻转字符串里的单词

344.反转字符串

思路：双指针法，从两边往中间走，交换两个指针对应的元素

/**
 * @param {character[]} s
 * @return {void} Do not return anything, modify s in-place instead.
 */
var reverseString = function(s) {
    let i = 0;
    let j = s.length - 1;
    let tem = 0;
    while (i < j) { //如果有偶数个字符，则刚好两两交换玩，如果有奇数个字符，最后i=j，无需交换
        tem = s[i];
        s[i] = s[j];
        s[j] = tem;

        i++;
        j--;
    }
    return;
};

注意：链表的地址不是连续存放的；而数组的地址是连续分布的；所以反转字符串要比反转链表简单一些；

541. 反转字符串II

！！！注意 JS中的字符串是不可变的，这意味着你不能直接修改字符串中的字符

需要将其转换为数组！！！

注意这题给的是字符串，而上一题给的是字符数组！！！

 const arr = s.split(''); // 将字符串转换为数组 2 return arr.join(''); // 将数组转换回字符串 

/**
 * @param {string} s
 * @param {number} k
 * @return {string}
 */
var reverseStr = function(s, k) {
    const arr = s.split(''); // 将字符串转换为数组
    for (let fast = 0; fast < arr.length - 1; fast += 2 * k) {
        if (fast + k <= arr.length - 1) {
            let tem = 0;
            let i = fast;
            let j = fast + k - 1;
            while (i < j) { //如果有偶数个字符，则刚好两两交换完，如果有奇数个字符，最后i=j，无需交换
                tem = s[i];
                arr[i] = s[j];
                arr[j] = tem;
                i++;
                j--;
            }
        } else {
            let tem = 0;
            let i = fast;
            let j = arr.length - 1;
            while (i < j) { //如果有偶数个字符，则刚好两两交换完，如果有奇数个字符，最后i=j，无需交换
                tem = arr[i];
                arr[i] = arr[j];
                arr[j] = tem;
                i++;
                j--;
            }
        }
    }
    return arr.join(''); // 将数组转换回字符串
};

剑指Offer 05.替换空格

新建一个数组arr2

/**
 * @param {string} s
 * @return {string}
 */
var replaceSpace = function(s) {
    const arr = s.split(''); //字符串转为数组
    //计算空格的数量，决定扩容空间
    let count=0;
    for(let i=0;i<arr.length;i++){
        if(arr[i]===' ') count++;
    }
    console.log(count);
    let arr2 = new Array(s.length+2*count);
    let j =arr.length-1;
    console.log(arr.length)
    console.log(arr2.length)
    for(let i = arr2.length-1;i>=0;){
        if(arr[j]==' '){
            arr2[i--]='0';
            arr2[i--]='2';
            arr2[i--]='%';
            j--;
        }
        else{
            arr2[i] = arr[j];
            j--;
            i--;
        }
    }
    console.log(arr2)
    return arr2.join('');
};

151.翻转字符串里的单词

思路：

1. 遍历整个数组，空格去重
2. 对整个数组进行翻转
3. 对单词进行翻转

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

    // 转为数组
    const arr = s.split('');

    // 空格去重
    let fast = 0;
    let slow = 0;
    while (fast < s.length) {
        // 移除开始位置和重复的空格
        if (arr[fast] === ' ' && (fast === 0 || arr[fast - 1] === ' ')) {
            fast++;
        } else {
            arr[slow++] = arr[fast++];
        }
    }
    // 移除末尾空格
    arr.length = arr[slow - 1] === ' ' ? slow - 1 : slow;

    console.log(slow);
    console.log(fast);
    console.log(arr);
    console.log(arr.length)

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

    // 整个数组翻转
    while (left < right) {
        tem = arr[right];
        arr[right] = arr[left];
        arr[left] = tem;

        // 收缩
        left++;
        right--;

    }

    console.log(arr);
    console.log(arr.length)

    // 单词翻转
    slow = 0; //指向单词的第一个字符
    fast = 0; //指向单词的第一个字符
    while (fast < arr.length) {
        //遍历元素，直到fast指向单词的最后一个字符
        while (arr[fast + 1] !== ' ' && fast < arr.length) {
            fast++;
        }

        // 翻转单个单词
        left = slow;
        right = fast;
        while (left < right) {
            tem = arr[right];
            arr[right] = arr[left];
            arr[left] = tem;
            // 收缩
            left++;
            right--;
        }

        // slow 和fast指向下一个单词的第一个字符重新开始下一个循环
        if (fast + 2 < arr.length) {
            fast += 2;
            slow = fast;
        } else break;
    }
    return arr.join('')

};

收获

1. 在 JavaScript 中，字符串和字符数组是两种不同的数据类型
2. 字符串（String）：字符串是 JavaScript 中的基本数据类型之一。它是一个包含零个或多个字符的文本序列，可以使用单引号（'）或双引号（"）来表示。字符串是不可变的，这意味着一旦创建，就不能直接修改字符串中的字符。字符串在 JavaScript 中有许多内置的方法，可以用于字符串的操作和处理，比如拼接、查找、替换、分割等。

3. const str = "Hello, world!";
   console.log(str.length); // 输出：13
   console.log(str.charAt(0)); // 输出：H
   console.log(str.slice(0, 5)); // 输出：Hello

    

4. 字符数组（Character Array）：
5. 在 JavaScript 中，字符数组通常指的是一个存储字符的数组。数组是一种数据结构，可以包含多个元素，每个元素可以是任意类型。在 JavaScript 中，数组的元素不必是相同的数据类型。字符数组通常通过将一系列字符存储在数组的各个索引位置来创建。

6. const charArray = ['H', 'e', 'l', 'l', 'o'];
   console.log(charArray.length); // 输出：5
   console.log(charArray[0]); // 输出：H