【LeetCode】-字符串

最新推荐文章于 2024-08-28 08:17:21 发布

电科_银尘

最新推荐文章于 2024-08-28 08:17:21 发布

阅读量196

点赞数

分类专栏： LeetCode 文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/wangshuqian1314/article/details/122781703

版权

LeetCode 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

本文详细介绍了在LeetCode上遇到的字符串操作题目，包括反转字符串、反转字符串II、替换空格、翻转字符串里的单词、左旋转字符串、实现strStr()函数以及查找重复子字符串的方法，涵盖了双指针、局部反转和整体反转等技巧，适合算法学习者参考。

摘要由CSDN通过智能技术生成

前言

初识LeetCode与算法，将在此系列文章里面，记录自己的算法学习经历，前期主要是监督自己学习打卡，后期我会将自己对知识的理解，慢慢补充到文章当中，希望大家能在阅读我的文章中，有所收获。该系列文章的刷题顺序以代码随想录为线索。

一、反转字符串

题目：
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

示例 1：

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

示例 2：

输入：s = [“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]

提示：

1 <= s.length <= 105
s[i] 都是 ASCII 码表中的可打印字符

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
1、使用双指针法，一个指向头指针，另一个指向尾指针，两指针同时向中间靠拢。

代码：

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

二、反转字符串 II

题目：
给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。

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

示例 1：

输入：s = “abcdefg”, k = 2
输出：“bacdfeg”

示例 2：

输入：s = “abcd”, k = 2
输出：“bacd”

提示：

1 <= s.length <= 104
s 仅由小写英文组成
1 <= k <= 104

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
使用一个for循环，同时指针走的步数是2*k的间距。利用reverse函数。

代码：

class Solution {
public:
    string reverseStr(string s, int k) {
        for(int i = 0; i < s.size(); i += (2*k)){
            if( i + k <= s.size()){
                reverse(s.begin()+i,s.begin()+i+k);
                continue;
            }
            reverse(s.begin()+i,s.begin()+s.size());
        }
        return s;
    }
};

三、替换空格

题目：
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：

输入：s = “We are happy.”
输出：“We%20are%20happy.”

限制：

0 <= s 的长度 <= 10000

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
使用一个for循环计算出空格的数目，再通过双指针的方法，从后面进行插入。

代码：

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 = sOldSize - 1, j = sNewSize - 1; i < j; i--,j--){
            if(s[i] != ' '){
                s[j] = s[i];
            }else{
                s[j] = '0';
                s[j - 1] = '2';
                s[j - 2] = '%';
                j -= 2;
            }
        }
        return s;
    }
};

四、翻转字符串里的单词

题目：
给你一个字符串 s ，逐个翻转字符串中的所有单词。

单词是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的单词分隔开。

请你返回一个翻转 s 中单词顺序并用单个空格相连的字符串。

说明：

输入字符串 s 可以在前面、后面或者单词间包含多余的空格。
翻转后单词间应当仅用一个空格分隔。
翻转后的字符串中不应包含额外的空格。

示例 1：

输入：s = “the sky is blue”
输出：“blue is sky the”

示例 2：

输入：s = " hello world "
输出：“world hello”
解释：输入字符串可以在前面或者后面包含多余的空格，但是翻转后的字符不能包括。

示例 3：

输入：s = “a good example”
输出：“example good a”
解释：如果两个单词间有多余的空格，将翻转后单词间的空格减少到只含一个。

示例 4：

输入：s = " Bob Loves Alice "
输出：“Alice Loves Bob”

示例 5：

输入：s = “Alice does not even like bob”
输出：“bob like even not does Alice”

提示：

1 <= s.length <= 104
s 包含英文大小写字母、数字和空格 ' '
s 中 至少存在一个 单词

进阶：

请尝试使用 O(1) 额外空间复杂度的原地解法。

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
先移除多余的空格，再将字符串进行颠倒排序，最后再把每个单词进行颠倒排序。

代码：

class Solution {
public:

    //反转字符串中左闭右闭的区间[start,end]
    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 slowIndex = 0,fastIndex = 0; //定义快慢指针
        //移除字符串开头的空格
        while(s.size() > 0 && fastIndex < s.size() && s[fastIndex] == ' '){
            fastIndex++;
        }
        //移除字符串中间的冗余空格
        for(;fastIndex < s.size(); fastIndex++){
            if(fastIndex - 1 > 0 && s[fastIndex] == s[fastIndex - 1] && s[fastIndex] == ' '){
                continue;
            }else{
                s[slowIndex++] = s[fastIndex];
            }
        }
        //移除字符串末尾的空格
        if(slowIndex - 1 > 0 && s[slowIndex - 1] == ' '){
            s.resize(slowIndex - 1);
        }else{
            s.resize(slowIndex);
        }
    }
    //将单词进行反转
    string reverseWords(string s) {
        removeExtraSpaces(s); //去除冗余的空格
        reverse(s, 0, s.size() - 1); //将字符串进行翻转
        int start = 0; //反转的单词在字符串中的起始位置
        int end = 0; //反转的单词在字符串中的结束位置
        bool entry = false; //标记枚举字符串的过程是否已经进入单词区间
        for(int i = 0; i < s.size(); i++){
            if(!entry){
                start = i; //确定单词的起始区间
                entry = true; //进入单词区间
            }
            //单词后面有空格的情况，单词后面就是分隔符
            if(entry && s[i] == ' ' && s[i - 1] != ' '){
                end = i - 1; //确定单词的终止位置
                entry = false;
                reverse(s, start, end);
            }
            //最后一个单词后面没有空格符
            if(entry && (i == (s.size() - 1)) && s[i] != ' '){
                end = i; //确定单词的终止位置
                entry = false;
                reverse(s, start, end);
            }
        }
        return s;
    }
};

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

题目：
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

示例 1：

输入: s = “abcdefg”, k = 2
输出: “cdefgab”

示例 2：

输入: s = “lrloseumgh”, k = 6
输出: “umghlrlose”

限制：

1 <= k < s.length <= 10000

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
使用局部反转和整体反转的方法

代码：

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        reverse(s.begin(), s.begin() + n);
        reverse(s.begin() + n, s.end());
        reverse(s.begin(), s.end());
        return s;
    }
};

六、实现 strStr()

题目：
实现 strStr() 函数。

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。

说明：

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。

示例 1：

输入：haystack = “hello”, needle = “ll”
输出：2

示例 2：

输入：haystack = “aaaaa”, needle = “bba”
输出：-1

示例 3：

输入：haystack = “”, needle = “”
输出：0

提示：

0 <= haystack.length, needle.length <= 5 * 104
haystack 和 needle 仅由小写英文字符组成

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
使用KMP算法

代码：

class Solution {
public:

    void getNext(int* next, const string& s){
        int j = -1;
        next[0] = j;
        for(int i = 1; i < s.size(); i++){
            while(j >= 0 && s[i] != s[j +1]){
                j = next[j];
            }
            if(s[j + 1] == s[i]){
                j++;
            }
            next[i] = j;
        }
    }
    int strStr(string haystack, string needle) {
        if(needle.size() == 0){
            return 0;
        }
        int next[needle.size()];
        getNext(next,needle);
        int j = -1;
        for(int i = 0; i < haystack.size(); i++){
            while(j >= 0 && haystack[i] != needle[j + 1]){
                j = next[j];
            }
            if(haystack[i] == needle[j + 1]){
                j++;
            }
            if(j == (needle.size() - 1)){
                return(i - needle.size() + 1);
            }
        }
        return -1;
    }
};

七、重复的子字符串

题目：
给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。

示例 1:

输入: s = “abab”
输出: true
解释: 可由子串 “ab” 重复两次构成。

示例 2:

输入: s = “aba”
输出: false

示例 3:

输入: s = “abcabcabcabc”
输出: true
解释: 可由子串 “abc” 重复四次构成。 (或子串 “abcabc” 重复两次构成。)

提示：

1 <= s.length <= 104
s 由小写英文字母组成

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
使用KMP算法

代码：

class Solution {
public:
    void getNext(int* next, const string& s){
        int j = -1;
        next[0] = j;
        for(int i = 1; i < s.size(); i++){
            while(j >= 0 && s[i] != s[j + 1]){
                j = next[j];
            }
            if(s[i] == s[j + 1]){
                j++;
            }
            next[i] = j;
        }
    }
    bool repeatedSubstringPattern(string s) {
        if(s.size() == 0){
            return false;
        }
        int next[s.size()];
        getNext(next,s);
        int len = s.size();
        if(next[len - 1] != -1 && (len % (len - (next[len - 1] + 1)) == 0)){
            return true;
        }
        return false;
    }
};