LeetCode刷题|day 8 字符串

344. 反转字符串 - 力扣（LeetCode）

此题需要注意i的取值范围！

循环里交换s[i]和s[j]可以使用库函数swap；

swap的实现有两种：

1. 常见的数值交换

int temp = s[i];
s[i]=s[j];
s[j]=temp;

2. 位运算

s[i] ^=s[j];
s[j] ^=s[i];
s[i] ^=s[j];

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

541. 反转字符串 II - 力扣（LeetCode）

此题主要是把复杂的规则搞清楚。

从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。

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

例：k=3，s='aehkgdhs','aeh'需要反转，且'hs'需要反转，反转后的字符串s'='heakgdsh'

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

例：k=2，s='aehkgdh'，'ae'需要反转，'gdh'需要反转，反转后的字符串s'='eahkhdg'

1、使用库函数法

class Solution {
public:
    string reverseStr(string s, int k) {
        //每隔2k个字符的前k个字符进行反转
        //剩余字符小于2k但大于或等于k，则反转前k个字符
        for(int i =0;i<s.size();i+=2*k){
            if(i+k<=s.size())//保证i+k在字符串范围内，不能超出
            {
                reverse(s.begin()+i,s.begin()+i+k);
            }else{
                //剩余字符少于k个，则将剩余字符全部反转
                reverse(s.begin()+i,s.end());//最后一段不够k个，需要全部反转
            }
        }
        return s;
    }
};

2、自己实现reverse函数

class Solution {
public:
    void reverse(string& s, int start, int end){
        for(int i=start,j=end;i<j;i++,j--){
            swap(s[i],s[j]);
        }
    }
    string reverseStr(string s, int k) {
        //每隔2k个字符的前k个字符进行反转
        //剩余字符小于2k但大于或等于k，则反转前k个字符
        for(int i =0;i<s.size();i+=2*k){
            if(i+k<=s.size())//保证i+k在字符串范围内，不能超出
            {
                reverse(s,i,i+k-1);
                continue;
            }else{
                //剩余字符少于k个，则将剩余字符全部反转
                reverse(s,i,s.size()-1);//最后一段不够k个，需要全部反转
            }
        }
        return s;
    }
};

class Solution {
public:
    string reverseStr(string s, int k) {
        int n = s.size(),pos=0;
        while(pos < n){
            if(pos + k < n) reverse(s.begin() + pos,s.begin() + pos + k);
            else reverse(s.begin()+pos,s.end());
            pos += 2*k;
        }
        return s;
    }
};

剑指 Offer 05. 替换空格 - 力扣（LeetCode）

思路：首先扩充数组到每个空格替换成"%20"之后的大小，然后从后向前替换空格，使用双指针法。

过程如下：i指向新长度的末尾，j指向旧长度的末尾。

数组填充类问题，都可以预先给数组扩容到填充后的大小，然后从后向前进行操作。

优点：1）不用申请新的数组；2）从后向前填充数组，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

class Solution {
public:
    string replaceSpace(string s) {
        int count=0;
        int soldsize = s.size();
        for(int i=0;i<s.size();i++){
            if(s[i]==' '){
                count++;
            }
        }
        s.resize(s.size()+count*2);
        int snewsize = s.size();
        for(int i = snewsize-1,j=soldsize-1;j<i;i--,j--){
            if(s[j]!=' '){
                s[i]=s[j];
            }else{
                s[i]='0';
                s[i-1]='2';
                s[i-2]='%';
                i -= 2;
            }

        }
        return s;
    }
};

拓展：字符串与数组的差别

字符串是若干字符组成的有限序列，也可以理解为一个字符数组。

在c语言中，把一个字符串存入一个数组时，也把结束符'\0'存入数组，并以此作为该字符串是否结束的标志。

char a[5]="asd";
for(int i=0;a[i]!='\0';i++){
}

在c++中会提供一个string类，string类会提供一个size接口，可以用来判断string类字符串是否结束，就不用'\0'来判断是否结束。

string a="asd";
for(int i= 0;i<a.size();i++){
}

那么vector< char > 和 string 又有什么区别呢？

其实在基本操作上没有区别，但是 string提供更多的字符串处理的相关接口，例如string 重载了+，而vector却没有。

所以想处理字符串，我们还是会定义一个string类型。

151. 反转字符串中的单词 - 力扣（LeetCode）

解题思路：

1. 移除多余空格

2. 将整个字符串反转

3. 将每个单词反转

例子：源字符串："the sky is blue "

移除多余空格："the sky is blue"

将整个字符串反转："eulb si yks eht"

将每个单词反转："blue is sky the"

使用双指针法移除空格（分别去除头尾和中间的空格）

    void removeExtraSpaces(string& s){
        int fast=0,slow=0;
        //移除字符串最前面的空格
        while(s.size()>0 && fast<s.size() && s[fast]==' '){
            fast++;
        }
        for(; fast<s.size();fast++){
        //去除字符串中间部分的冗余空格
            if(fast-1>0 && s[fast-1] == s[fast] && s[fast] == ' '){
                continue;
            }else{
                s[slow++]=s[fast];
            }
        }
        if(slow-1>0 && s[slow-1] == ' '){
        //去除字符串末尾的空格
            s.resize(slow-1);
        }else{
            s.resize(slow);
        }
    }

去除所有的空格然后再在中间添加空格

class Solution {
public:
    void reverse(string& s,int start, int end){
        for(int i = start,j=end; i<j; i++,j--){
            swap(s[i], s[j]);
        }
    }
    void removeExtraSpaces(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);
    }
    string reverseWords(string s) {
        removeExtraSpaces(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;
            }
        }
        return s;
    }
};