第四章 字符串part01

 今日任务 

•  344.反转字符串

•  541. 反转字符串II

•  剑指Offer 05.替换空格

•  151.翻转字符串里的单词

•  剑指Offer58-II.左旋转字符串

 详细布置 

 344.反转字符串 

建议： 本题是字符串基础题目，就是考察 reverse 函数的实现，同时也明确一下 平时刷题什么时候用 库函数，什么时候 不用库函数 

题目链接/文章讲解/视频讲解：代码随想录

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

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

题目链接/文章讲解/视频讲解：代码随想录

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);
                //s.begin() 指指向s的开头迭代器，每次都把相应的 那一组对调 reverse
            }else{
                reverse(s.begin() + i, s.end());
            }
        }
        return s;
    }
};

 剑指Offer 05.替换空格  这题没了，变成从.到空格

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

题目链接/文章讲解：代码随想录

class Solution {
public:
    string pathEncryption(string path) {
        int numofpoint = 0;
        
        for(int i = 0;i < path.size();i++){
            if(path[i] == '.'){
                path[i] = ' ';
            }
        }
        return path;
    }
};

 151.翻转字符串里的单词 

建议：这道题目基本把 刚刚做过的字符串操作 都覆盖了，不过就算知道解题思路，本题代码并不容易写，要多练一练。 

题目链接/文章讲解/视频讲解：代码随想录

在C++中，& 在函数参数的类型前面表示该参数是一个引用。当你将一个对象传递给一个采用引用参数的函数时，你实际上是将原始对象传递给该函数，而不是该对象的一个副本。

这有几个重要的后果：

1. 性能: 当传递大对象（如字符串、向量或其他容器）时，使用引用可以避免复制这些对象，从而提高性能。

2. 修改原始数据: 因为你传递的是原始对象的引用，所以在函数内对该参数所做的任何修改都会影响到调用者看到的原始对象。

s[slowIndex++] = s[fastIndex];

该运算符的行为是：首先返回当前值，然后再增加。

先去空格，再完全反转，再挨个单词反转

class Solution {
public:
    void removeExtraSpaces(string& s){
        int slowIndex = 0;
        int fasterIndex = 0;
        // 输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。
        // 前导，字母前的空格
        while(s.size()>0&& fasterIndex < s.size() && s[fasterIndex] == ' '){
            // 为啥有size>0
            fasterIndex++;
        }
        // 冗余空格
        for(;fasterIndex<s.size();fasterIndex++){
            // fasterIndex出现两个空格就应该搞掉一个，先避免fasterIndex？？？？处理冗余避开一开始？？
            // 
            if(fasterIndex > 1 && s[fasterIndex-1] == ' '&& s[fasterIndex] ==' ' ){
                continue;
            }else{
                s[slowIndex] = s[fasterIndex];
                slowIndex++; 
            }// 忽略连续空格，的第234个空格，只将需要的值赋值上去

        }
        // 尾随空格 要是原本faster遍历的尾随空格，slow会被只留下一个空格，因为重复的删掉了，所以就一个判断
        if(slowIndex > 1 && s[slowIndex - 1] == ' '){
            s.resize(slowIndex - 1);
        }else{
            s.resize(slowIndex);
        }
    }
    // // 版本二 
    // 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的大小即为去除多余空格后的大小。
    // }   
    //版本san
         // 可以但是效率低
        // for(int i = 0 ;i<s.size();i++){
        //     if(s[i] = ' '&&s[i-1] = ' '){
        //         s.erase(s.begin() + i);
        //         //s.erase(s.begin() + i); 是 C++ 中的代码片段，用于从容器（如 std::string、std::vector 等）中删除一个元素。
        //     }
        // }
    void reverse(string& s, int start, int end){ //翻转，区间写法：左闭右闭 []
        for (int i = start, j = end; i < j; i++, j--) {
            swap(s[i], s[j]);
        }
    }


    string reverseWords(string s) {
        removeExtraSpaces(s);
        reverse(s, 0, s.size() - 1);
        // 空格合适，但是字母完全颠倒
        int wortstart = 0;
        for(int i = 0;i <= s.size();i++){
            if(s[i] == ' '||i == s.size()){
                reverse(s,wortstart,i-1);
                wortstart = i + 1;
            }
        }
        return s;

    }
};

 剑指Offer58-II.左旋转字符串 

建议：题解中的解法如果没接触过的话，应该会想不到

题目链接/文章讲解：代码随想录

class Solution {
public:
    string dynamicPassword(string password, int target) {
        int slowIndex = 0;
        int fasterIndex = target;
        int size = password.size();
        string targetStr(target, 'a');
        for(;slowIndex<size;slowIndex++,fasterIndex++){
            if(slowIndex < target){
                targetStr[slowIndex] = password[slowIndex];
                password[slowIndex] = password[fasterIndex];
            }
            if( target <= slowIndex< (size - target)){
                password[slowIndex] = password[fasterIndex];
            }
            if((size - target) <= slowIndex ){
                password[slowIndex] = targetStr[slowIndex-(size - target)];;
            }
           // cout<< password << endl;
        }
        return password; 
    }
};

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;
    }
};
//人家写的真牛