【Leetcode字符串--双指针】344. 反转字符串 541. 反转字符串 II（模拟的好坏之分！！）

Leetcode344

1.问题描述

2.解决方案

(1)C++直接首尾交换，没什么好说的

class Solution {
public:
    void reverseString(vector<char>& s) {
        int left=0;
        int right=s.size()-1;
        while(left<right){
            swap(s[left],s[right]);
            left++;
            right--;
        }
        return;
    }
};

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

(2)错误Java方法，没有改变内存区域里面的值，只是把c指向的变了，原本的内存区域没变

class Solution {
    public void reverseString(char[] s) {
        StringBuilder sb = (new StringBuilder(String.valueOf(s))).reverse();
        s = sb.toString().toCharArray();
    }
}

(3)正确Java交换值

class Solution {
    public void reverseString(char[] s) {
        int left = 0;
        int right = s.length-1;
        while(left<=right){
            char t = s[left];
            s[left] = s[right];
            s[right] = t;

            left++;
            right--;
        }
    }
}

Leetcode541

1.问题描述

2.解决方案

C++版本：

思路很简单就直接模拟，但是时间上需要很好的模拟，统一化处理才会很快，前面错误的就是没模拟好，后面的算法模拟的很好，这个回来看看慢慢熏陶！

//错误麻烦的
class Solution {
public:
    string reverseStr(string s, int k) {
        int count=0;
        for(int i=0;i<s.size();i++){
            count++;
            if((count%(2*k)==0)) reverse(s[i-2*k+1],s[i-2*k+1+k]);
        }
        int end=count%(2*k);
        if(end<k){
            reverse(s[s.size()-end],s[s.size()]);
        }
        if(end>=k){
            reverse(s[s.size()-end],s[s.size()]);
        }
    }
};

//正确的简洁的
class Solution1 {
public:
    string reverseStr(string s, int k) {
        for (int i=0; i<s.size();i+=(2 * k)) {
            //将以下两种情况统一处理，reverse左闭右开
            //1.每隔2k个字符的前k个字符进行反转
            //2.剩余字符小于2k但大于或等于k个，则反转前k个字符
            if (i + k <= s.size()) {
                reverse(s.begin() + i, s.begin() + i + k );
                continue;
            }
            //3.剩余字符少于k个，则将剩余字符全部反转
            reverse(s.begin() + i, s.begin() + s.size());
        }
        return s;
    }
};

Java版本：

1.先反转2k的整数倍
2.然后对于小于2k长度的剩余部分，分三种情况讨论，最终决定剩下的部分怎么反转

class Solution {
    public void reverse(char[] s, int left, int right){
        while(left<=right){
            char t = s[left];
            s[left] = s[right];
            s[right] = t;

            left++;
            right--;
        }
    }
    public String reverseStr(String s, int k) {
        char[] chars = s.toCharArray();
        int cnt = chars.length / (2*k);
        int i = 0;
        while(i<cnt){
            int left = 0 + (i++)*2*k;
            int right = left + k - 1;
            reverse(chars, left, right);
        }
        int left = 0 + cnt*2*k;
        int right = left + k;
        //1.如果正好是2k的整数倍
        if(left>chars.length-1){}
        //2.如果剩余的小于k了直接反转剩余的
        else if(right>chars.length-1) {
            reverse(chars, left, chars.length-1);
        }
        //3.说明剩余的长度 k<len<2k 反转left到right-1即可
        else{
            reverse(chars, left, right-1);
        }
        return new String(chars);
    }
}