【代码随想录】字符串——“字符串”相关题目

344. 反转字符串

在206反转链表的时候，使用了“双指针”的方法，这里也是用“双指针”的方法。（超级简单）

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

    }
};

541. 反转字符串 II

一些同学可能为了处理逻辑：每隔2k个字符的前k的字符，写了一堆逻辑代码或者再搞一个计数器，来统计2k，再统计前k个字符（是我了！狠狠哭了） 

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

if(i+k<=s.size()){//剩余字符小于 2k 但大于或等于 k 个，反转前 k 个字符（i+k<=s.size,表明剩余字符是超过或等于k个的）

continue;//跳出本次循环，到下一个i处

class Solution {
public:
    string reverseStr(string s, int k) {
        for(int i=0;i<s.size();i+=(2*k)){
            //i+=(2*k)，即i每次移动 2 * k 
            //判断是否有需要反转的区间
            if(i+k<=s.size()){//剩余字符小于 2k 但大于或等于 k 个，反转前 k 个字符（i+k<=s.size,表明剩余字符是超过或等于k个的）
                reverse(s.begin()+i,s.begin()+i+k);
                continue;//跳出本次循环，到下一个i处
            }
            //剩余字符少于 k 个，将剩余字符全部反转
            reverse(s.begin()+i,s.end());
        }
        return s;
    }
};

剑指 Offer 05. 替换空格

方法一：用上substr，有点费内存。遇上空格，将原来的字符串截成两半，中间空格的位置插入“%20”。接着将它们用+号串起来 

class Solution {
public:
    string replaceSpace(string s) {
        for(int i=0;i<s.size();i++){
            if(s[i]==' '){
                s=s.substr(0,i)+"%20"+s.substr(i+1,s.size()-i-1);
            }
        }
        return s;

    }
};

方法二：双指针法

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

 这么做有两个好处：

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

// 扩充字符串s的大小，也就是每个空格替换成"%20"之后的大小。每个空格多增加2个字符长度，因此是count*2
s.resize(oldSize+count*2); 

//i指向扩容后末尾(新)，j指向扩容前末尾（旧）

//以旧指针遍历寻找空格。

if(s[j]!=' '){//以旧指针遍历寻找空格
    s[i]=s[j];
}

class Solution {
public:
    string replaceSpace(string s) {
        int oldSize=s.size(),count=0;//count用于统计字符串中空格的个数
        for(int i=0;i<oldSize;i++){
            if(s[i]==' ') count++;
        }
        // 扩充字符串s的大小，也就是每个空格替换成"%20"之后的大小。每个空格多增加2个字符长度，因此是count*2
        s.resize(oldSize+count*2);
        int newSize=s.size();
        for(int i=newSize-1,j=oldSize-1;j<i;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;
    }
};

151. 颠倒字符串中的单词

方法一：双指针法 

将整个字符串都反转过来，那么单词的顺序指定是倒序了，只不过单词本身也倒序了，那么再把单词反转一下，单词不就正过来了

所以解题思路如下：（整体反转+局部反转 的思想）

• 移除多余空格（整体思想类似于“移除元素”那题，只不过这里的元素是指空格）
• 将整个字符串反转（用定义的函数reverse反转）
• 将每个单词反转(遍历字符串，遇到空格或者指针i到字符串末尾，用定义的函数reverse反转)

举个例子，源字符串为："the sky is blue "

• 移除多余空格 : "the sky is blue"
• 字符串反转："eulb si yks eht"
• 单词反转："blue is sky the"

细节看注释 

class Solution {
public:
    void removeSpace(string &s){//一开始忘记写&符号
        int slow=0;
        for(int fast=0;fast<s.size();fast++){//整体思想类似于“移除元素”那题，这里移除的元素是空格
            if(s[fast]!=' '){//非空格就处理，表明删除所有多余空格
                if(slow>0){//以下操作需要在单词前添加空格，slow>0说明不是第一个单词。（第一个单词前不需空格）
                    s[slow]=' ';//在一个完整单词之后添加一个空格，保证单词之间只有一个空格
                    slow++;
                }
                while(fast<s.size() && s[fast]!=' '){//处理完整的一个单词
                    s[slow]=s[fast];
                    slow++;
                    fast++;
                }
            }
        }
        s.resize(slow);//slow的大小即为去除多余空格后的大小。

    }
    void reverse(string &s,int strat,int end){
        int left=strat,right=end;
        while(left<right){
            swap(s[left],s[right]);
            left++;
            right--;
        }
    }

    string reverseWords(string s) {
        removeSpace(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);//注意i-1才是单词的结尾
                start=i+1;
            }
        }
        return s;
    }
};

方法二：栈法 

1、定义一个存放字符的栈，返回结果的字符串res

2、指针i从后往前遍历，遇到非空格，就将字符push进栈；当再遇到空格或者指针位置指向0时，表明完整一个单词已经存进栈，需要将其pop出来到res中（小细节：得加一个标志位来判断，表明只有能进入循环，res才可以加空格（也即是单词之间加一个空格，否则会加很多个空格）if(flag) res+=' ';）

3、返回res（注意返回时，resd由于上面单词之间加一个空格的缘故，此时的res最后一个字符是空格，需要把它去掉）

class Solution {
public:
    string reverseWords(string s) {
        stack<char> word;//存放从后往前遍历的单词
        string res="";
        for(int i=s.size()-1;i>=0;i--){
            if(s[i]!=' '){//非空格才处理
                word.push(s[i]);
            }
            if(i==0 || s[i]==' '){//i==0时，如果s[0]非空格，前面一入栈，到这里就该出栈（到头了）
                bool flag=false;
                while(!word.empty()){
                    res+=word.top();
                    word.pop();
                    flag=true;
                }
                //res+=' ';//如果这样，当word为空s[i]又是空格时，没进入while循环,res就会加很多空格
                //所以得加一个标志位来判断（能进入循环，才有res加空格）
                if(flag) res+=' ';
            }
        }
        //res=res.substr(0,res.size()-1);
        return res.substr(0,res.size()-1);//从0位置开始，拷贝res.size()-1长度的，减1是因为res末尾有个空格
    }
};

剑指 Offer 58 - II. 左旋转字符串

方法一：用库函数substr串起来（额外申请了空间，费内存）

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        string res="";
        res=s.substr(n,s.size()-n)+s.substr(0,n);
        return res;
    }
};

方法二：整体反转+局部反转的思想 

具体步骤为：

1. 反转区间为前n的子串
2. 反转区间为n到末尾的子串
3. 反转整个字符串

class Solution {
public:
    void reverse(string &s,int begin,int end){
        int left=begin,right=end;
        while(left<right){
            swap(s[left],s[right]);
            left++;
            right--;
        }
    }
    string reverseLeftWords(string s, int n) {
        reverse(s,0,n-1);//先反转前n个字符
        reverse(s,n,s.size()-1);//再反转n~末尾的字符
        reverse(s,0,s.size()-1);//反转整个字符串
        return s;
    }
};

28. 实现 strStr()

KMP经典题目

KMP的经典思想就是:当出现字符串不匹配时，可以记录一部分之前已经匹配的文本内容，利用这些信息避免从头再去做匹配。

前缀表是什么，为什么需要前缀表，怎么找前缀表？？

next数组就是一个前缀表（prefix table），前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。（模式串是主串的子串）

例如要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。

如果使用暴力法解决该问题，文本串中第六个字符b 和 模式串的第六个字符f，不匹配了，就会从头开始匹配。但如果使用前缀表，就不会从头匹配，而是从上次已经匹配的内容开始匹配，找到了模式串中第三个字符b继续开始匹配。

在某个字符失配时，前缀表会告诉你下一步匹配中，模式串应该跳到哪个位置。

前缀表：记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串。

后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。

比如：下标5之前这部分的字符串（也就是字符串aabaa）的最长相等的前缀 和 后缀字符串是 子字符串aa ，因此找到了最长相等的前缀和后缀。以上中，匹配失败的位置是后缀子串的后面，那么我们找到与其相同的前缀子串的后面重新匹配就可以了。（找最长长度的相同前缀后缀子串的目的就在此，即前缀表的目的在此）

计算的前缀表如下图：

可以看出模式串与前缀表对应位置的数字表示的就是：下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

前缀表如何来做匹配？？

当找到不匹配的位置， 那么此时我们要看它的前一个字符的前缀表的数值是多少。

为什么要前一个字符的前缀表的数值呢，因为要找前面字符串的最长相同的前缀和后缀。

所以要看前一位的 前缀表的数值。

前一个字符的前缀表的数值是2， 所有把下标移动到模式串中下标2的位置继续比配

next数组与前缀表的关系？？

next数组就可以是前缀表，但是很多实现都是把前缀表统一减一（右移一位，初始位置为-1）之后作为next数组 

其实这并不涉及到KMP的原理，而是具体实现，next数组即可以就是前缀表，也可以是前缀表统一减一（右移一位，初始位置为-1）。

时间复杂度分析

其中n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置，可以看出匹配的过程是O(n)，之前还要单独生成next数组，时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)的。

暴力的解法显而易见是O(n × m)，所以KMP在字符串匹配中极大的提高的搜索的效率。

解题过程

其实，求next数组的过程完全可以看成字符串匹配的过程，即以模式字符串为主字符串，以模式字符串的前缀为目标字符串，一旦字符串匹配成功，那么当前的next值就是匹配成功的字符串的长度。 具体来说，就是从模式字符串的第一位(注意，不包括第0位)开始对自身进行匹配运算。 在任一位置，能匹配的最长长度就是当前位置的next值。构造next数组其实就是计算模式串s，前缀表的过程。 主要有如下三步：

1. 初始化
2. 处理前后缀不相同的情况
3. 处理前后缀相同的情况