代码随想录打卡第八天 | 字符串 leetcode344&541&151 卡码网54&55-CSDN博客

本文链接：https://blog.csdn.net/weixin_43364099/article/details/138923770

卡码网54&55（已经凌晨12:13了，这两个题周末复习时再做。。。）

344 - 反转字符串

输入：s = ["h","e","l","l","o"]
输出：["o","l","l","e","h"]

思路：

1、类似于双指针的方法，左指针指向0，右指针指向s.size() - 1（最后一位）

2、左右数据交换；

3、左右指针相向而行，直到左指针>=右指针退出；

提交代码

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

541 - 反转字符串 II

输入：s = "abcdefg", k = 2
输出："bacdfeg"
给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。

如果剩余字符少于 k 个，则将剩余字符全部反转。

如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

思路：

1、计算有多少个2K； s.size()/k;

2、剩余数据长度len<k, 还是k<len<2k s.size()%k;

3、处理数据；

思路就是这样，但是写的时候有很多坑，都是必须自己一个个踩过去的。。。我写了一个多小时才通过。。。。后面再找找有没有什么简便方法(分成一个个子串分别处理应该会更简单！！！)

提交代码

class Solution {
public:
    string reverseStr(string s, int k) {
        int size = s.size();
        if(size < k){
            for(int i = 0; i < size/2; ++i){//size < k反转全部
                swap(s[i], s[size - 1 - i]);
            }
            return s;
        }
        else if(size >= k && size < 2 * k){//k <= size < 2k反转前k个
            for(int i = 0; i < k/2; ++i){
                    swap(s[i], s[k - 1 - i]);
            }
            return s;
        }
        else if(size >= 2 * k){
            int rest = size % (2*k);
            int idx = 0;    //当前遍历第几个2k
            int last = size - 1 - (size % k);     //最后一个需要反转的元素下标
            for(int i = 0; i < s.size(); ++i){//
                if((s.size() - i - 1) < rest){//遍历到rest范围了
                    if(rest >= k && i <= last){   //k <= len < 2k,反转前k个
                        swap(s[i], s[last--]);
                    }
                    else if (rest >= k && i > last){//k <= len < 2k,前k个之外不反转
                        break;
                    }
                    else if(rest < k){   // len < k  全部反转
                        if(i < size - 1 -i%k){
                            swap(s[i], s[size - 1 - i%k]);
                        }
                    }
                }
                else{   //n * 2k范围内
                    idx = i / (2 * k) + 1;
                    int last = idx * 2 * k - 1; //n * 2k的最后一位下标
                    if(i < last - k - i%(2*k)){
                        swap(s[i], s[last - k - i%(2*k)]);
                    }
                }
            }
        }
        return s;
    }

    void test(){
        reverseStr( "abcdefg", 2);
    }
};

151 - 反转字符串中的单词

输入：s = "the sky is blue"
输出："blue is sky the"
输入：s = " hello world "
输出："world hello"

输入：s = "a good example"
输出："example good a"

思路：

1、本题看起来简单，使用数组分别存储子串再反转，但实际上有很多坑；

2、比如：空格，原来字符串中带多个空格，你反转后不同单词间隔只能有一个空格：

原来字符串的前后带空格，你处理之后的不能带，比如："the abc is good ", 你必须把good后面的‘ ’去掉，但是它也会出现"the abd is good", "the abc is good"," the abc is good ",各种情况，空格‘ ’可能出现在任何位置，要针对空格做很多特殊处理！！

提交代码


class Solution {
public:
    string reverseWords(string s) {
        vector<string> vec;
        int start = 0;
        // int end = 0;
         for(int i = 0; i < s.size(); ++i){
            if(s[i] == ' '){
                if(i != 0)  //第一个字符为空格不能插入
                    vec.emplace_back(string(s.begin() + start, s.begin() + i));
                start = i + 1;
                while(s[start] == ' '){ //"the abs   ddd" 出现多个空格，开始位置后移找到第一个非空格
                    ++start;
                    i = start;
                }
            }
            if(i == s.size() - 1){
                int end = s.size() - 1;
                if(start <= end){    //start < end说明还有最后一个单词需要拷贝，如“the sbhc t ”
                    //到了sbhc之后这个‘ ’处，此时还需要将t放入vec
                    while(s[end] == ' '){   //最后一个为空格，往前移动一格
                        end--;
                    }
                    vec.emplace_back(string(s.begin() + start, s.begin() + end + 1));
                }
                else if(start > end){  //start >= end 说明最后一个单词不用拷贝了，如“the sbhc tt ”,
                    //到了“tt”之后的‘ ’处，此时"tt"已经放入vec, start > end
                    break;
                }

            }
        }

        for(int i  = 0; i < vec.size()/2; ++i){
            swap(vec[i], vec[vec.size() - 1 - i]);
        }

        string out = "";
        for(int i  = 0; i < vec.size(); ++i){
            out += vec[i];
            if(i < vec.size() - 1)
            out += " ";
        }

        return out;
    }

    void test(){
        reverseWords(" asdasd df f");
    }
};