代码随想录算法训练营第8天｜344. 反转字符串，541. 反转字符串 II, 151. 反转字符串中的单词, 剑指 Offer 05. 替换空格，剑指 Offer 58 - II. 左旋转字符串

JazcsP922

已于 2023-06-24 02:05:03 修改

阅读量123

点赞数

文章标签： leetcode c++ 算法

于 2023-01-18 15:07:09 首次发布

本文链接：https://blog.csdn.net/JazcsP922/article/details/128726085

版权

Day 8

344. 反转字符串

class Solution {
public:
    void reverseString(vector<char>& s) {
        int n = s.size();
        for (int left = 0, right = n - 1; left < right; ++left, --right) {
            swap(s[left], s[right]);
        }
    }
};

对于字符串，我们定义两个指针（也可以说是索引下标），一个从字符串前面，一个从字符串后面，两个指针同时向中间移动，并交换元素。这里使用了swap 这个库函数。

class Solution {
    public void reverseString(char[] s) {
        //双指针
        int left = 0;
        int right = s.length-1;
        char temp;
        while (left<right){
            temp = s[left];
            s[left] = s[right];
            s[right] = temp;
            right--;
            left ++ ;
        }
    }
}

使用左右双指针分别指向字符串数组的头和尾
交换左右指针的字符，然后左右指针前移right–和left ++，直到两个指针相遇

java版：

class Solution {
    public void reverseString(char[] s) {
        int n = s.length;
        for (int left = 0, right = n - 1; left < right; ++left, --right) {
            char tmp = s[left];
            s[left] = s[right];
            s[right] = tmp;
        }
    }
}

541. 反转字符串 II

class Solution {
public:
    string reverseStr(string s, int k) {
        int n = s.length();
        for (int i = 0; i < n; i += 2 * k) {
            reverse(s.begin() + i, s.begin() + min(i + k, n));
        }
        return s;
    }
};

class Solution {
public:
    string reverseStr(string s, int k) {
        for(int i = 0; i < s.size(); i += (2*k)){
            if(i + k <= s.size()){
                reverse(s.begin() + i, s.begin() + i + k);
            }
            else{
                reverse(s.begin() + i, s.end());
            }
        }
        return s;
    }
};

本题的重点在于for循环中逻辑的判断，不在于库函数实现原理，所以可以考虑使用reverse()函数。
当需要固定规律一段一段去处理字符串的时候，要想想在在for循环的表达式上做做文章

java版：

class Solution {
    public String reverseStr(String s, int k) {
        int n = s.length();
        char[] arr = s.toCharArray();
        for (int i = 0; i < n; i += 2 * k) {
            reverse(arr, i, Math.min(i + k, n) - 1);
        }
        return new String(arr);
    }

    public void reverse(char[] arr, int left, int right) {
        while (left < right) {
            char temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
}

151. 反转字符串中的单词

class Solution {
public:
    string reverseWords(string s) {
        reverse(s.begin(), s.end());

        int n = s.size();
        int idx = 0;
        for (int start = 0; start < n; ++start) {
            if (s[start] != ' ') {
                if (idx != 0) s[idx++] = ' ';

                int end = start;
                while (end < n && s[end] != ' ') s[idx++] = s[end++];

                reverse(s.begin() + idx - (end - start), s.begin() + idx);

                start = end;
            }
        }
        s.erase(s.begin() + idx, s.end());
        return s;
    }
};

class Solution {
public:
    void reverse(string& s, int start, int end){
        for(int i = start, j = end; i < j; i++, j--){
            swap(s[i], s[j]);
        }
    }
 
    void removeExtraSpaces(string& s){
        int slow = 0;
        for(int i = 0; i < s.size(); i++){
            if(s[i] != ' '){
                if(slow != 0)
                    s[slow++] = ' ';
                while(i < s.size() && s[i] != ' '){
                    s[slow++] = s[i++];
                }
            }
        }
        s.resize(slow);
    }
    string reverseWords(string s) {
        removeExtraSpaces(s);
        reverse(s, 0, s.size() - 1);
        int start = 0;
        for(int i = 1; i <= s.size(); i++){
            if(i == s.size() || s[i] == ' '){
                reverse(s, start, i - 1);
                start = i + 1;
            }
        }
        return s;
    }
};

本题可以使用split库函数，分隔单词，然后定义一个新的string字符串，最后再把单词倒序相加。但是这么做就失去了意义。

整体的思路是将整个字符串倒过来，然后再分别将每个单词再次倒过来，这样单词就正过来了，同时字符串也翻转了。

本题需要注意的点是空格的处理：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。输出字符串单词间只使用一个空格相连。所以我们应该先对字符串进行处理，删除其多余的空格，在removeExtraSpaces()函数中，使用快慢指针法，定义一个slow指针和一个i指针，在i指针遍历整个字符串的for循环中，如果i指的位置是空格，那么就跳过这个i，这样就应对了连续多个空格的情况；当i指的位置为非空格时，就对slow指针指的位置赋一个空格，同时slow++，这时i下一个单词的开头，然后使用while循环将单词赋给slow所指向的位置，最后返回一个slow长度的字符串，这样就做到了去除多余空格的操作。

关于自定义函数中形参的问题：形参中输入的值需为string& s，它输入的是字符串的引用，这样就可以直接对字符串本体进行操作。如果使用string s按值传递，函数处理的值是它本地的拷贝，这些拷贝被存储在运行栈中，因此改变这些值不会影响实参的值。一旦函数结束了，函数的活动记录将从栈中弹出，这些局部值也就消失了。在按值传递的情况下，实参的内容没有被改变。具体说明可见此处

java版：

class Solution {
    public String reverseWords(String s) {
        int left = 0, right = s.length() - 1;
        // 去掉字符串开头的空白字符
        while (left <= right && s.charAt(left) == ' ') {
            ++left;
        }

        // 去掉字符串末尾的空白字符
        while (left <= right && s.charAt(right) == ' ') {
            --right;
        }

        Deque<String> d = new ArrayDeque<String>();
        StringBuilder word = new StringBuilder();
        
        while (left <= right) {
            char c = s.charAt(left);
            if ((word.length() != 0) && (c == ' ')) {
                // 将单词 push 到队列的头部
                d.offerFirst(word.toString());
                word.setLength(0);
            } else if (c != ' ') {
                word.append(c);
            }
            ++left;
        }
        d.offerFirst(word.toString());

        return String.join(" ", d);
    }
}

剑指 Offer 05. 替换空格

class Solution {
public:
    string replaceSpace(string s) {
        int count = 0, len = s.size();

        for (char c : s) {
            if (c == ' ') count++;
        }

        s.resize(len + 2 * count);

        for(int i = len - 1, j = s.size() - 1; i < j; i--, j--) {
            if (s[i] != ' ')
                s[j] = s[i];
            else {
                s[j - 2] = '%';
                s[j - 1] = '2';
                s[j] = '0';
                j -= 2;
            }
        }
        return s;
    }
};

本题使用双指针法，先记录原字符串的长度，并遍历字符串找到其中空格字符的数量。随后使用resize()函数扩充数组到每个空格替换成"%20"之后的大小。然后从后向前替换空格，也就是双指针法，过程如下：i指向新长度的末尾，j指向旧长度的末尾

从前向后填充就是O(n^2)的算法了，因为每次添加元素都要将添加元素之后的所有元素向后移动。其实很多数组填充类的问题，都可以先预先给数组扩容带填充后的大小，然后在从后向前进行操作。这么做有两个好处：1、不用申请新数组。2、从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

java版：

class Solution {
    public String replaceSpace(String s) {
        int length = s.length();
        char[] array = new char[length * 3];
        int size = 0;
        for (int i = 0; i < length; i++) {
            char c = s.charAt(i);
            if (c == ' ') {
                array[size++] = '%';
                array[size++] = '2';
                array[size++] = '0';
            } else {
                array[size++] = c;
            }
        }
        String newStr = new String(array, 0, size);
        return newStr;
    }
}

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

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        reverse(s.begin(), s.begin()+n);
        reverse(s.begin() + n, s.end());
        reverse(s.begin(), s.end());
        return s;
    }
};

我们可以想一下上一题目翻转字符串里的单词，使用整体反转+局部反转就可以实现反转单词顺序的目的。这道题目也非常类似，依然可以通过局部反转+整体反转达到左旋转的目的。

具体步骤为：反转区间为前n的子串、反转区间为n到末尾的子串、反转整个字符串。

java版：

class Solution {
    public String reverseLeftWords(String s, int n) {
        return s.substring(n, s.length()) + s.substring(0, n);
    }
}

JazcsP922

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第8天｜344. 反转字符串，541. 反转字符串 II, 151. 反转字符串中的单词, 剑指 Offer 05. 替换空格，剑指 Offer 58 - II. 左旋转字符串

344. 反转字符串，541. 反转字符串 II, 151. 反转字符串中的单词, 剑指 Offer 05. 替换空格，剑指 Offer 58 - II. 左旋转字符串解题
复制链接

扫一扫