【LeetCode】5.字符串系列

总目录：

LeetCode系列导航目录

 

0.理论基础

0.1.要点

很简单。

字符串可以视作char数组，可以使用索引访问char。

有很多标准库可以用，如可以很方便获得长度。

每个char是一个ASCII数值。

1.翻转字符串

1.1.问题描述

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
示例 1：输入：s = ["h","e","l","l","o"]输出：["o","l","l","e","h"]
链接：https://leetcode.cn/problems/reverse-string

1.2.要点

注意要求空间复杂度O(1)

1双指针，对撞即可

1.3.代码实例

双指针

class Solution {
public:
    void reverseString(vector<char>& s) {
        int dataLen=s.size();
        if(dataLen<=0){
            return;
        }

        int left=0,right=dataLen-1;
        while(left<right){
            swap(s[left],s[right]);
            left++;
            right--;
        }
    }
};

 

2.翻转字符串2

2.1.问题描述

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
（1）如果剩余字符少于 k 个，则将剩余字符全部反转。
（2）如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
示例 1：输入：s = "abcdefg", k = 2；输出："bacdfeg"
链接：https://leetcode.cn/problems/reverse-string-ii

2.2.要点

这是一种模拟题，按间距翻转，翻转一段不翻转一段

1迭代+状态机，保存当前段是否应该翻转

2双指针

左指针每步长2k，右指针为左指针+k-1，注意右指针初始化时不要超过s长度

2.3.代码实例

1状态机

class Solution {
public:
    string reverseStr(string s, int k) {
        int dataLen=s.length();
        string ret;
        if(dataLen<=0){
            return ret;
        }

        
        bool needRev=true;//决定正序还是逆序，默认逆序
        for(int i=0;i<dataLen;i+=k){
            if(needRev){
                for(int j=k-1;j>=0;j--){
                    if((i+j)>=dataLen){
                        continue;
                    }
                    ret+=s[i+j];
                }
            }
            else{
                for(int j=0;j<k;j++){
                    if((i+j)>=dataLen){
                        continue;
                    }
                    ret+=s[i+j];
                }
            }
            needRev=!needRev;
        }

        return ret;
    }
};

2双指针

class Solution {
public:
    string reverseStr(string s, int k) {
        int dataLen=s.length();        
        int left=0,right=0;

        for(; left < dataLen; left += 2*k){
            right = min(left+k, dataLen);
            reverse(s.begin()+left, s.begin() + right);
        }

        return s;
    }
};

 

3.替换空格

3.1.问题描述

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
示例 1：输入：s = "We are happy."；输出："We%20are%20happy."
链接：https://leetcode.cn/problems/ti-huan-kong-ge-lcof

3.2.要点

这里的方法区别仅仅是空间复杂度O(1)还是O(n)，

即原地修改还是新建字符串。

3.3.代码实例

原地修改,双指针

class Solution {
public:
    string replaceSpace(string s) {
        int count = 0, len = s.size();
        // 统计空格数量
        for (char c : s) {
            if (c == ' ') count++;
        }
        // 修改 s 长度
        s.resize(len + 2 * count);
        // 倒序遍历修改
        for(int i = len - 1, j = s.size() - 1; i < j; i--, j--) {
            if (s[i] != ' ')
                s[j] = s[i];
            else {
                s[j - 2] = '%';
                s[j - 1] = '2';
                s[j] = '0';
                j -= 2;
            }
        }
        return s;
    }
};

新建字符串

class Solution {
public:
    string replaceSpace(string s) {
        int n=s.size();
        string str="";
        for(int i=0;i<n;++i)
            str=(s[i]==' ' ? str+"%20" : str+s[i]);
        return str;
    }
};

 

4.翻转字符串中的单词

4.1.问题描述

给你一个字符串 s ，请你反转字符串中 单词 的顺序。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
链接：https://leetcode.cn/problems/reverse-words-in-a-string

4.2.要点

1两次翻转，非原地操作，先翻转整体，再翻转局部

2双端队列，插入内容比较方便

4.3.代码实例

两次翻转

class Solution {
public:
    string reverseWords(string s) {
        int dataLen=s.length();
        string newStr;
        
        reverse(s.begin(),s.end());
        int left=0,right=0;
        while(left<dataLen){
            //寻找第一个非空格
            if(s[left]==' '){
                left++;
                continue;
            }

            //寻找右边界
            right=left;
            while(right<dataLen){
                if(s[right]==' '){
                    break;
                }
                right++;
            }

            //翻转局部
            reverse(s.begin()+left,s.begin()+right);
            for(int i=left;i<right;i++){
                newStr+=s[i];
            }            

            //查看后面是否还有有效数据
            int nextAvaPos = 0;
            for(int i = right; i < dataLen; i++){
                if(s[i] != ' '){
                    nextAvaPos = i;
                    break;
                }
            }            
            
            //决定是否添加间隔符并继续迭代
            if(nextAvaPos!=0){                
                newStr+=' ';//附加间隔符
                left=nextAvaPos;
            }
            else{
                break;
            }   
        }        
        
        return newStr;
    }
};

5.左旋转字符串

5.1.问题描述

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
示例 1：输入: s = "abcdefg", k = 2；输出: "cdefgab"
链接：https://leetcode.cn/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof

5.2.要点

1字符串裁剪

2字符遍历

3三次翻转

5.3.代码实例

三次翻转

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        /* 反转n前面的字符串 */
        reverse(s.begin(), s.begin() + n);
        /* 反转n后面的字符串 */
        reverse(s.begin() + n, s.end());
        /* 反转整个字符串 */
        reverse(s.begin(), s.end());

        return s;
    }
};

 

6.找出字符串第一个匹配项的下标

6.1.问题描述

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回  -1 。
示例 1：输入：haystack = "sadbutsad", needle = "sad"；输出：0；解释："sad" 在下标 0 和 6 处匹配。第一个匹配项的下标是 0 ，所以返回 0 。
示例 2：输入：haystack = "leetcode", needle = "leeto"；输出：-1；解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。
链接：https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string

6.2.要点

1模拟，枚举，状态机

从匹配上第一个字符开始，就检查是否能匹配上后面所有

2KMP

6.3.代码实例

模拟、枚举

class Solution {
public:
    int strStr(string s, string p) {
        int n = s.size(), m = p.size();
        for(int i = 0; i <= n - m; i++){
            int j = i, k = 0; 
            while(k < m and s[j] == p[k]){
                j++;
                k++;
            }
            if(k == m) return i;
        }
        return -1;
    }
};

KMP

class Solution {
public:
    int strStr(string s, string p) {
        int n = s.size(), m = p.size();
        if(m == 0) return 0;
        //设置哨兵
        s.insert(s.begin(),' ');
        p.insert(p.begin(),' ');
        vector<int> next(m + 1);
        //预处理next数组
        for(int i = 2, j = 0; i <= m; i++){
            while(j and p[i] != p[j + 1]) j = next[j];
            if(p[i] == p[j + 1]) j++;
            next[i] = j;
        }
        //匹配过程
        for(int i = 1, j = 0; i <= n; i++){
            while(j and s[i] != p[j + 1]) j = next[j];
            if(s[i] == p[j + 1]) j++;
            if(j == m) return i - m;
        }
        return -1;
    }
};

 

7.重复的子字符串

7.1.问题描述

给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。
示例 1:输入: s = "abab"；输出: true；解释: 可由子串 "ab" 重复两次构成。
链接：https://leetcode.cn/problems/repeated-substring-pattern

7.2.要点

1模拟，状态机

子串增长，当母串的下一个字符与子串头相同时，进入尝试使用子串匹配后面所有内容的环节

2kmp算法，暂未看懂

7.3.代码实例

模拟，状态机

class Solution {
public:
    //start\end都是闭
    bool isMatch(string str,int start,string match){
        int tgtLen=match.length();
        if(str.length() < (start+tgtLen)){
            return false;
        }

        for(int i=0;i<tgtLen;i++){
            if(str[start+i]!=match[i]){
                return false;
            }
        }
        
        return true;
    }
    
    bool repeatedSubstringPattern(string s) {
        int dataLen=s.length();
        string strSub;
        int strSubSize=0;
        for(int i=0;i<dataLen;i++){
            strSub+=s[i];

            //如果前方到头或与子串开头不同，则继续
            if(i == (dataLen-1) || s[i+1]!=strSub[0]){
                continue;
            }

            //是否可以被整除
            strSubSize=strSub.size();
            if(dataLen%strSubSize!=0){
                continue;
            }

            //循环检查后面的内容
            int start = i+1;
            while(start < dataLen){
                //查询是否匹配
                if(!isMatch(s,start,strSub)){
                    break;
                }
                start += strSubSize;
                if(start >= dataLen){
                    return true;
                }
            }
        }


        return false;
    }
};

KMP算法

class Solution {
public:
    bool kmp(const string& query, const string& pattern) {
        int n = query.size();
        int m = pattern.size();
        vector<int> fail(m, -1);
        for (int i = 1; i < m; ++i) {
            int j = fail[i - 1];
            while (j != -1 && pattern[j + 1] != pattern[i]) {
                j = fail[j];
            }
            if (pattern[j + 1] == pattern[i]) {
                fail[i] = j + 1;
            }
        }
        int match = -1;
        for (int i = 1; i < n - 1; ++i) {
            while (match != -1 && pattern[match + 1] != query[i]) {
                match = fail[match];
            }
            if (pattern[match + 1] == query[i]) {
                ++match;
                if (match == m - 1) {
                    return true;
                }
            }
        }
        return false;
    }

    bool repeatedSubstringPattern(string s) {
        return kmp(s + s, s);
    }
};

 

8.总结

8.1.KMP要点

KMP算法https://github.com/hitwzy/leetcode-master/blob/master/problems/0028.%E5%AE%9E%E7%8E%B0strStr.md

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

精髓所在就是前缀表。

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

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

针对前缀表到底要不要减一，这其实是不同KMP实现的方式。

其中主要理解j=next[x]这一步最为关键。

 8.2常用套路

双指针法是字符串处理的常客，因为字符串可以很方便地获取总长度、最后的地址。

 

 

 

 

 

xxx.问题

xxx.1.问题描述

111

xxx.2.要点

222

xxx.3.代码实例

333