算法day08|字符串part01|Leetcode344、541、151|卡码网55

344.反转字符串

字符串基础题目，考察reverse函数的实现。
同时明确平时刷题什么时候用库函数，什么时候不用库函数。
在算法思路上，字符串和数组实际上是差不多的.
代码如下：

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]);
        }
    }
};

541.反转字符串II

处理批量数据时，可以在for循环里修改

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;
    }
};

卡码网：54替换数字

扩充数组到每个数字字符替换成 “number” 之后的大小,不要只用额外的辅助空间

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

这么做有两个好处：

1.不用申请新数组。
2.从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

代码如下：

#include <iostream>
using namespace std;
int main() {
    string s;
    while (cin >> s) {
        int sOldIndex = s.size() - 1;
        int count = 0; // 统计数字的个数
        for (int i = 0; i < s.size(); i++) {
            if (s[i] >= '0' && s[i] <= '9') {
                count++;
            }
        }
        // 扩充字符串s的大小，也就是将每个数字替换成"number"之后的大小
        s.resize(s.size() + count * 5);
        int sNewIndex = s.size() - 1;
        // 从后往前将数字替换为"number"
        while (sOldIndex >= 0) {
            if (s[sOldIndex] >= '0' && s[sOldIndex] <= '9') {
                s[sNewIndex--] = 'r';
                s[sNewIndex--] = 'e';
                s[sNewIndex--] = 'b';
                s[sNewIndex--] = 'm';
                s[sNewIndex--] = 'u';
                s[sNewIndex--] = 'n';
            } else {
                s[sNewIndex--] = s[sOldIndex];
            }
            sOldIndex--;
        }
        cout << s << endl;       
    }
}

151.翻转字符串里的单词

方法一：split函数，使用语言特性 (python)

class Solution:
    def reverseWords(self, s: str) -> str:
        return " ".join(reversed(s.split()))

方法二：不要使用辅助空间(即原地求解)，空间复杂度要求为O(1)
不仅要翻转字符串，还需要删除多余的空格
思路： 先翻转整个字符串，然后再把每个单词都翻转
难点： 删除多余的空格

普通想法：for循环遍历字符串，如果遇到空格就调用erase删除空格
因为在数组(字符串)中删除或添加元素，需要整体移动后面的元素，所以时间复杂度是O(n)
这样做法不好的地方在于：由于erase的时间复杂度为O(n)，所以整体的时间复杂度就是O(n^2).

双指针法删除多余空格 时间复杂度：O(n)
思路与Leetcode 27. 移除元素是一样的。

移除元素要求在一个数组里删除所有值为val的元素，设置快慢指针，慢指针指向的是我们需要的元素，快指针负责遍历数组，当快指针指向需要保留元素(不为val)，把快指针赋给慢指针并且慢指针++，即快指针指向要删除的val时，慢指针保持不动，快指针则继续遍历到一个元素。

删除多余空格的思路是：慢指针指向我们需要的元素，快指针遍历整个字符串，当快指针遇到非空格(我们需要的单词)就处理，此时首先判断slow是否为0(即是否为首位)，如果不是首位就赋空格再++(单词之间的那个空格)，接着用一个while把单词从快指针赋值给慢指针直到遭遇空格。

整体代码如下：

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;   //整体思想参考https://programmercarl.com/0027.移除元素.html
        for (int i = 0; i < s.size(); ++i) { //
            if (s[i] != ' ') { //遇到非空格就处理，即删除所有空格。
                if (slow != 0) s[slow++] = ' '; //手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。
                while (i < s.size() && s[i] != ' ') { //补上该单词，遇到空格说明单词结束。
                    s[slow++] = s[i++];
                }
            }
        }
        s.resize(slow); //slow的大小即为去除多余空格后的大小。
    }

    string reverseWords(string s) {
        removeExtraSpaces(s); //去除多余空格，保证单词之间之只有一个空格，且字符串首尾没空格。
        reverse(s, 0, s.size() - 1);
        int start = 0; //removeExtraSpaces后保证第一个单词的开始下标一定是0。
        for (int i = 0; i <= s.size(); ++i) {
            if (i == s.size() || s[i] == ' ') { //到达空格或者串尾，说明一个单词结束。进行翻转。
                reverse(s, start, i - 1); //翻转，注意是左闭右闭 []的翻转。
                start = i + 1; //更新下一个单词的开始下标start
            }
        }
        return s;
    }
};

P.S. 这道题目我尝试了reverse函数使用左闭右开的方法来做，在考虑边界的问题相较麻烦一些，
因为左闭右闭的写法的意思明显，就是交换这个区间内的值，不用把右边界+1来考虑。
注意for循环这里是 i <= s.size() 这里的目的是为了 i能够取到s.size()这个值，这样就能判断i是否到达边界，在左闭右开的方法中也可以这么写。
总之在考虑边界问题的时候，只要考虑到底需要哪些元素在这些区间里就行，可以多运行调试来尝试。

卡码网：55.右旋转字符串

为了让本题更有意义，提升一下本题难度：不能申请额外空间，只能在本串上操作。

本题中，我们需要将字符串右移n位，字符串相当于分成了两个部分，如果n为2，符串相当于分成了两个部分。
右移n位， 就是将第二段放在前面，第一段放在后面，先不考虑里面字符的顺序，是不是整体倒叙不就行了。
此时第一段和第二段的顺序是我们想要的，但里面的字符位置被我们倒叙，那么此时我们在把 第一段和第二段里面的字符再倒叙一把，这样字符顺序不就正确了。

假设总长度为len， 需要移动n位
右翻转：先整体翻转，再把翻转n区间和len- n区间。

// 版本一
#include<iostream>
#include<algorithm>
using namespace std;
int main() {
    int n;
    string s;
    cin >> n;
    cin >> s;
    int len = s.size(); //获取长度

    reverse(s.begin(), s.end()); // 整体反转
    reverse(s.begin(), s.begin() + n); // 先反转前一段，长度n
    reverse(s.begin() + n, s.end()); // 再反转后一段

    cout << s << endl;

}

左翻转：先翻转len-n和n，最后翻转整体。

#include<iostream>
#include<algorithm>
using namespace std;
int main() {
    int n;
    string s;
    cin >> n;
    cin >> s;
    int len = s.size(); //获取长度
    reverse(s.begin(), s.begin() + len - n); // 先反转前一段，长度len-n ，注意这里是和版本一的区别
    reverse(s.begin() + len - n, s.end()); // 再反转后一段
    reverse(s.begin(), s.end()); // 整体反转
    cout << s << endl;

}