Day_7 字符串part01 344.反转字符串 、541. 反转字符串II 、卡码网：54.替换数字

### 344.反转字符串

建议： 本题是字符串基础题目，就是考察 reverse 函数[[String#12.反转字符串 [Day_7 344.反转字符串 、541. 反转字符串II 、卡码网：54.替换数字 344.反转字符串 ]]]的实现，同时也明确一下 平时刷题什么时候用 库函数，什么时候 不用库函数

题目链接/文章讲解/视频讲解：[https://programmercarl.com/0344.%E5%8F%8D%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2.html](https://programmercarl.com/0344.%E5%8F%8D%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2.html)

（1）思路：
双指针法[[双指针（包括滑动窗口）#^84702a|字符串反转]]

(2)代码如下（尽量不要使用库函数,交换可以直接用swap）:
```
class Solution {
public:
    void reverseString(vector<char>& s) {
        for (int i = 0, j = s.size() - 1; i < s.size()/2; i++, j--) {
            swap(s[i],s[j]);
        }
    }
};
```

### 541. 反转字符串II

建议：本题又进阶了，自己先去独立做一做，然后在看题解，对代码技巧会有很深的体会。

题目链接/文章讲解/视频讲解：[https://programmercarl.com/0541.%E5%8F%8D%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2II.html](https://programmercarl.com/0541.%E5%8F%8D%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2II.html)

(1)思路：
给定一个字符串 `s` 和一个整数 `k`，从字符串开头算起，每计数至 `2k` 个字符，就反转这 `2k` 字符中的前 `k` 个字符。
如果剩余字符少于 `k` 个，则将剩余字符全部反转。
如果剩余字符小于 `2k` 但大于或等于 `k` 个，则反转前 `k` 个字符，其余字符保持原样。

找反转起始点是没有问题的，但是可以按照前面一题的思路提供end，而不是提供k，且i每次加2*k（循环）

(2)代码：
我的：
```
class Solution {
public:
    string reverseStr(string s, int k) {
        string res=s;
        int n=s.size();
        int tmp=n;
        while(1){
            if(tmp<2*k){
                res=reverseStrk(res,k,n-tmp+1);
                break;
            }
            else{
                res=reverseStrk(res,k,n-tmp+1);
                tmp-=2*k;
            }
        }
        return res;
    }
    string reverseStrk(string t,int k,int start){
        int i=start,j=min(start+k-1,static_cast<int>(t.size()));
        while(i<=j){
            swap(t[i-1],t[j-1]);
            i++;
            j--;
        }
        return t;
    }
};
```

示例1（用reverse(知道头和尾，可以学习这个思路)):
```
class Solution {
public:
    string reverseStr(string s, int k) {
        for (int i = 0; i < s.size(); i += (2 * k)) {
            // 1. 每隔 2k 个字符的前 k 个字符进行反转
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            if (i + k <= s.size()) {
                reverse(s.begin() + i, s.begin() + i + k );
            } else {
                // 3. 剩余字符少于 k 个，则将剩余字符全部反转。
                reverse(s.begin() + i, s.end());
            }
        }
        return s;
    }
};
```
### 范围确定

1. **`i + k <= s.size()` 判断条件**：
    
    - `i` 是当前处理块的起始索引。(索引范围：[0,s.size()))
    - `i + k` 是当前块结束位置的下一个索引（非包含）。//偏移k个单位,[i,i+k)
    - `s.size()` 是字符串 `s` 的总长度。
    - `i + k <= s.size()`(两开可以相等,下一索引未到最后，说明至少有k个) (这个条件确保当前块的长度至少为 `k`，即在字符串范围内。
2. **`reverse(s.begin() + i, s.begin() + i + k)`**：//左闭右开
    
    - `s.begin() + i` 是迭代器，指向第 `i` 个字符。
    - `s.begin() + i + k` 是迭代器，指向第 `i + k` 个字符。
    - `reverse` 的范围是 `[s.begin() + i, s.begin() + i + k)`，即包含 `s.begin() + i` 但不包含 `s.begin() + i + k`，正好反转前 `k` 个字符。
3. **`reverse(s.begin() + i, s.end())`**：
    
    - `s.begin() + i` 是迭代器，指向第 `i` 个字符。
    - `s.end()` 是迭代器，指向字符串末尾后的一个位置。
    - `reverse` 的范围是 `[s.begin() + i, s.end())`，即包含 `s.begin() + i` 直到字符串结束。
示例2：
```
class Solution {
public:
    void reverse(string& s, int start, int end) {//用引用,自定义reverse函数是两闭区间
        for (int i = start, j = end; i < j; i++, j--) {
            swap(s[i], s[j]);
        }
    }
    string reverseStr(string s, int k) {
        for (int i = 0; i < s.size(); i += (2 * k)) {
            // 1. 每隔 2k 个字符的前 k 个字符进行反转
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            if (i + k <= s.size()) {
                reverse(s, i, i + k - 1);//闭区间要减1
                continue;
            }
            // 3. 剩余字符少于 k 个，则将剩余字符全部反转。
            reverse(s, i, s.size() - 1);//闭区间要减1
        }
        return s;
    }
};
```

### 卡码网：54.替换数字

建议：对于线性数据结构，填充或者删除，后序处理会高效的多。好好体会一下。

题目链接/文章讲解：[https://programmercarl.com/kama54.%E6%9B%BF%E6%8D%A2%E6%95%B0%E5%AD%97.html](https://programmercarl.com/kama54.%E6%9B%BF%E6%8D%A2%E6%95%B0%E5%AD%97.html)

(1)思路：
1.直接用replace[[String#11.替换子字符串]]

2.双指针法从后向前替换数字字符(使用双指针法是为了在不额外分配新空间的情况下就地对字符串进行修改。具体来说，这里用到的双指针技术主要是为了避免在字符串中间插入和移动字符，从而提高效率。)(利用双指针来高效地完成字符串的原地修改。)
为什么要从后向前填充，从前向后填充不行么？
从前向后填充就是O(n^2)的算法了，因为每次添加元素都要将添加元素之后的所有元素整体向后移动。
**其实很多数组填充类的问题，其做法都是先预先给数组扩容带填充后的大小（resize），然后在从后向前进行操作。**
这么做有两个好处：
1. 不用申请新数组。
2. 从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

（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);//[[String#14.调整容器的大小]]
        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;       
    }
}
```