DAY8 字符串344.541.151.剑指05.剑指58

454.反转字符串

基础操作，使用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.反转字符串2

每2k个字符串位置反转k个字符，变量i在自增的时候使用i += (2*k)；

class Solution {
public:
    string reverseStr(string s, int k) {
        for (int i = 0; i<s.size(); i += (2*k)){
            if (s.size()-i<k){
                for (int j = i, t = s.size()-1; j<(i+s.size())/2; j++, t--){
                    swap(s[j], s[t]);
                }
                break;
            }
            for (int j = i, t = i + k - 1; j<i+(k/2); j++, t--){
                swap(s[j], s[t]);
            }
        }
        return s;
    }

};

151.反转字符串中的单词

class Solution {
public:
    // 思路，首先将整个字符串反转，
    string reverseWords(string s) {
        Reverse(s, 0, s.size()-1);
        
        int start = 0;
        for (int i = 0; i<=s.size();i++){
            if (i == s.size() || s[i] == ' '){
                Reverse(s, start, i-1);
                start = i +1;
            }
        }
        eraseBlank(s);
        return s;

    }

    void eraseBlank(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); //slow 最后的位置就是删掉所有空格之后字符串的长度。
    }

    void Reverse(string& s, int begin, int end){
        for (int i = begin, j = end; i<j; i++, j--){
            swap(s[i], s[j]);
        }
    }
};

剑指offer 05.替换空格

//思路，首先扩充数组，其次从后往前填数组；

//如何将s数组扩充count位置？
        s.resize(OldSize + 2 * count);

//双指针自后向前填充数组；

class Solution {
public:
    string replaceSpace(string s) {
        //思路，首先扩充数组，其次从后往前填数组；
        int count = 0;
        int OldSize = s.size();
        for (int i = 0; i<s.size(); i++){
            if (s[i] == ' '){
                count++;
            }
        }

        //如何将s数组扩充count位置？
        s.resize(OldSize + 2 * count);

        //双指针填充数组；
        int k = OldSize-1;
        // k指针应该从原数组的最后一位开始向前移动；
        for (int j=s.size()-1; j>0; j--){ 
            // j指针从新数组的最后一位向前移动；
            if (s[k] != ' '){
                s[j] = s[k]; // 这是k指向的内容为字母的时候；
            }
            else {
                s[j] = '0';
                s[j-1] = '2';
                s[j-2] = '%';
                j = j-2;
            }
            k--;
        }
        return s;
    }
};

剑指58-2.左旋转字符串

       // 思路：先反转前n个字母，再反转剩下的s.size-n个字母；

        // 最终反转所有字母；

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        // 思路：先反转前n个字母，再反转剩下的s.size-n个字母；
        // 最终反转所有字母；
        int length = s.size()-1;
        Reserve(s, 0, n-1);
        Reserve(s, n, length);
        Reserve(s, 0, length);

        return s;
    }

    void Reserve (string& s, int begin, int end){
        for (int i = begin, j = end; i<j; i++, j--){
            swap(s[i], s[j]);
        }

    }
};