反转字符串II

双指针法

class Solution {
public:
    string reverseStr(string s, int k) {
        int n = s.size();
        int start = 0, end = n - 1;
        while(start < n) {
            if(start + 2 * k < n) { //剩余的字符>=2*k个,则一定可以找到下一段起点.
                reverse(s.begin() + start, s.begin() + start + k);
                start = start + 2 * k; 
            }
            else if(start + k > n) { //不足k个
                reverse(s.begin() + start, s.end());
                break;
            }
            else { //剩余字符大于等于k小于2k个
                reverse(s.begin() + start, s.begin() + start + k);
                break;
            }
        }
        return s;
    }
};

双指针简化版

class Solution {
public:
    string reverseStr(string s, int k) {
        int n = s.size();
        int start = 0, end = n - 1;
        while(start < n) {
            if(start + k > n) { //不足k个，超出了字符串范围
              reverse(s.begin() + start, s.end());
              break;
            }
            reverse(s.begin() + start, s.begin() + start + k);
            start = start + 2 * k; 
        }
        return s;
    }
};

改进版1

其实还有一种做法就是在遍历字符串的过程中，只要让 i += (2 * k)，i 每次移动 2 * k 就可以了，然后判断是否需要有反转的区间。

因为要找的也就是每2 * k 区间的起点，这样写程序会高效很多。

「所以当需要固定规律一段一段去处理字符串的时候，要想想在在for循环的表达式上做做文章。」

class Solution {
public:
    string reverseStr(string s, int k) {
        for (int i = 0; i < s.size(); i += (2 * k)) {
            // 1. 每隔 2k 个字符的前 k 个字符进行反转，也就是剩余字符>=2k,则一定可以找到下一段起点，
            //放心反转本段前k个字符即可
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            //包含着剩余元素大于2k情况
            if (i + k <s.size()) {
                reverse(s.begin() + i, s.begin() + i + k );//+i是因为要先追上i，然后才进行偏移
                continue;
            }
            // 3. 剩余字符少于 k 个，则将剩余字符全部反转。
            //通俗点说，给定一个字符串，我站在第一个字符上向后计数，如果+K个后超出范围，说明本字符后面不足k个
            reverse(s.begin() + i, s.begin() + s.size());
        }
        return s;
    }
};

改进版2

class Solution {
public:
    void reverse(string &s,int start,int end){
        for(;start<end;start++,end--){
            swap(s[start],s[end]);    
        }
    }
    
    string reverseStr(string s, int k) {
        for (int i = 0; i < s.size(); i += (2 * k)) {
            // 1. 每隔 2k 个字符的前 k 个字符进行反转，也就是剩余字符>=2k,则一定可以找到下一段起点，
            //放心反转本段前k个字符即可
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            if (i + k <= s.size()) {
                reverse(s,i,i + k-1 );//+i是因为要先追上i，然后才进行偏移
                continue;
            }
            // 3. 剩余字符少于 k 个，则将剩余字符全部反转。
            //通俗点说，给定一个字符串，我站在第一个字符上向后计数，如果+K个后超出范围，说明本字符后面不足k个
            reverse(s,i,s.size()-1);
        }
        return s;
    }
};