【23】反转字符串 II | 反转字符串中的单词 III （LeetCode 541 |557）

反转字符串 II

问题描述

给定一个字符串 s 和一个整数 k，你需要对从字符串开头算起的每隔 2k 个字符的前 k 个字符进行反转。

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

解题思路

先分组，再反转。将2*k个字符分为一组，找到组中需要反转的起点和终点，然后反转。

class Solution {
public:
    void reverse(string& s,int low,int high){//反转字符串
        while(low<high){
            swap(s[low],s[high]);
            low++;
            high--;
        }
    }
    string reverseStr(string s, int k) {
        int n=s.size();
        int i=0;
        while(i*2*k<n){
            int begin=i*2*k;//分组后的起点
            int end;
            //分组后的终点
            if(i*2*k+k-1<n-1)//最后一组字符数不小于k的情况
                end=i*2*k+k-1;
            else//最后一组字符数小于k的情况
                end=n-1;
            reverse(s,begin,end);
            i++;
        }
        return s;
    }
};

时间复杂度：O（n）
空间复杂度：O（1）

反转字符串中的单词 III

问题描述

给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

例子：

解题思路

以空格为标志提取出单词，额外使用一个字符串temp存储反转后的单词，额外使用一个字符串res存储反转后的单词组成的句子。

class Solution {
public:
    string reverseWords(string s) {
        int n=s.size();
        int i=0;
        string res;
        while(i<n){
            if(s[i]==' '){ //如果是空格，则保留
                res=res+' ';
                i++;
            }
            string temp="";
            while(i<n && s[i]!=' '){//反转单词
                cout<<s[i]<<endl;
                temp=s[i]+temp;
                i++;
            }
            res=res+temp;//将反转后的单词组合起来
        }
        return res;
    }
};

时间复杂度：O（n）
空间复杂度：O（n）

不过算法的优化空间还很大。

进行了优化：

class Solution {
public:
    void reverse(string& s,int low,int high){
        while(low<high){
            swap(s[low],s[high]);
            low++;
            high--;
        }
    }
    string reverseWords(string s) {
        int n=s.size();
        int i=0;
        while(i<n){
            int begin=i;
            while(i<n && s[i]!=' ')
                i++;
            int end=i-1;
            reverse(s,begin,end);
            i++;
        }
        return s;
    }
};

如上，思想是以空格分组，找到组内开头和结尾进行分组。

空间上有了很大的优化，只用了常数的额外空间，复杂度为O（1）。

时间上虽然还是O（n），但是利用了双指针，在进行单词内反转时的遍历次数为单词长度的一半，因此有了一定的优化。