代码随想录刷题笔记4——字符串

最新推荐文章于 2024-09-03 17:22:28 发布
最新推荐文章于 2024-09-03 17:22:28 发布
阅读量54 收藏
点赞数
分类专栏： leetcode刷题 文章标签： 笔记 c++ c语言 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhj12138/article/details/132676362
版权

反转字符串

例题344（简单）反转字符串

注意要点：

  1. 只需要遍历一半，每次交换首尾即可。

下面贴出代码：

CPP版本

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

C版本

void reverseString(char* s, int sSize){
    for (int i = 0; i < sSize / 2; i++)
    {
        int tmp = s[i];
        s[i] = s[sSize - 1 - i];
        s[sSize - 1 - i] = tmp;
    }
}

拓展题541（简单）反转字符串II

注意要点：

  1. 直接通过for循环，循环变量i+=2k即可完成每次递增2k，然后判断翻转即可。

下面贴出代码：

CPP版本

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);
            }
            else {reverse(s.begin() + i, s.end());}
        }
        return s;
    }
};

C版本

char * reverseStr(char * s, int k){
    int len = strlen(s);
    for (int i = 0; i < len; i += 2 * k)
    {
        int right = fmin(i + k - 1, len - 1);
        int left = i;
        while (left < right)
        {
            char tmp = s[right];
            s[right] = s[left];
            s[left] = tmp;
            left++;
            right--;
        }
    }
    return s;
}

替换空格

例题 剑指Offer05（简单）替换空格

注意要点：

  1. 从前往后的暴力解法需要移动数组位置，所以时间复杂度是O(n^2)；
  2. 双指针法，先统计出所需数组的大小，然后从后往前填充，复杂度降为O(n)。
  3. C++可以直接 resize() 数组的大小。

下面贴出代码：

CPP版本

class Solution {
public:
    string replaceSpace(string s) {
        //统计空格数量
        int count = 0;
        for (int i = 0; i < s.size(); i++)
        {
            if (s[i] == ' ') {count++;}
        }
        //扩充为所需的数组大小
        int oldSize = s.size();
        s.resize(s.size() + 2 * count);
        int newSize = s.size();
        for (int i = newSize - 1, j = oldSize - 1; i >= 0, j >= 0; i--, j--)
        {
            if (s[j] == ' ')
            {
                s[i--] = '0';
                s[i--] = '2';
                s[i] = '%';
            }
            else {s[i] = s[j];}
        }
        return s;
    }
};

C版本

char* replaceSpace(char* s){
    int size = 0;
    for (int i = 0; i < strlen(s); i++)
    {
        if (s[i] != ' ') {size++;}
        else {size += 3;}
    }
    char* ans = (char* )malloc(sizeof(char) * (size + 1));
    int ptr_s = strlen(s) - 1, ptr_ans = size;
    ans[ptr_ans] = '\0';
    ptr_ans--;
    while (ptr_s >= 0)
    {
        if (s[ptr_s] != ' ')
        {
            ans[ptr_ans] = s[ptr_s];
            ptr_s--;
            ptr_ans--;
        }
        else
        {
            ans[ptr_ans] = '0';
            ans[ptr_ans-1] = '2';
            ans[ptr_ans-2] = '%';
            ptr_ans -= 3;
            ptr_s--;
        }
    }
    return ans;
}

翻转字符串中的单词

例题151（中等）反转字符串中的单词

注意要点：

  1. 最重要的思路：首先先删掉多余的空格，反转整个字符串，然后寻找到每一个单词，再把单词翻转；
  2. 删除多余的空格，使用快慢指针就可以，类似之前的移除元素；
  3. 反转可以直接库函数reverse，也可以自己写，我是写了一个左闭右开的翻转函数；
  4. 如果使用void修改原字符串，需要注意传参就需要传入原先字符串的首地址。

下面贴出代码：

CPP版本

class Solution {
public:
    void myreverse(string& s, int start, int end)
    {
        int mid = start + (end - start) / 2;
        for (int i = start; i < mid; i++)
        {
            swap(s[i], s[end - 1 - (i - start)]);
        }
    }

    void removeExtraSpaces(string& s)
    {
        int slow = 0;
        for (int i = 0; i < s.size(); i++)
        {
            if (s[i] != ' ')
            {
                if (slow) {s[slow++]  = ' ';}
                while (i < s.size() && s[i] != ' ') {s[slow++] = s[i++];}
            }
        }
        s.resize(slow);
    }

    string reverseWords(string s) {
        removeExtraSpaces(s);
        myreverse(s, 0, s.size());
        int start = 0;
        for (int i = 0; i <= s.size(); i++)
        {
            if (i == s.size() || s[i] == ' ')
            {
                myreverse(s, start, i);
                start = i + 1;
            }
        }
        return s;
    }
};

C版本

char * reverseWords(char * s){
    int slow = 0;
    for (int i = 0; i < strlen(s); i++)
    {
        if (s[i] != ' ')
        {
            if (slow) {s[slow++]  = ' ';}
            while (i < strlen(s) && s[i] != ' ') {s[slow++] = s[i++];}
        }
    }
    s[slow] = '\0';

    int left = 0, right = strlen(s) - 1;  // 当前头部仍可能有空格时的字符串长度
    while (left < right)
    {
        char tmp = s[right];
        s[right] = s[left];
        s[left] = tmp;
        left++;
        right--;
    }
    int len_tmp = strlen(s);

    int len = strlen(s);
    // 接下来翻转单词
    int word_left = 0;
    for (int i = 0; i < len + 1; i++)
    {
        if (s[i] == ' ' || s[i] == '\0')
        {
            int word_right = i - 1;
            while (word_left < word_right)
            {
                char tmp = s[word_right];
                s[word_right] = s[word_left];
                s[word_left] = tmp;
                word_left++;
                word_right--;
            }
            word_left = i + 1;
        }
    }
    return s;
}

左旋转字符串

例题 剑指Offer58-II（简单）左旋转字符串

注意要点：

  1. 类似上一题，都是直接翻转再加局部翻转。

下面贴出代码：

CPP版本

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

C版本

void reverse(char* s, int start, int end)
{
    int left = start, right = end - 1;
    while (left < right)
    {
        char tmp = s[left];
        s[left] = s[right];
        s[right] = tmp;
        left++;
        right--;
    }
}

char* reverseLeftWords(char* s, int n){
    reverse(s, 0, strlen(s));
    reverse(s, 0, strlen(s) - n);
    reverse(s, strlen(s) - n, strlen(s));
    return s;
}

KMP算法

这不是代码随想录的分类方法，他的分类逻辑是根据题目讲解某种算法。但是这种算法我之前一刷完成后，只有在字符串这个章节中出现，但是却又非常重要（不会的话有些题直接很难做），所以单独开一个专题记录一下笔记。

KMP算法可以用作字符串匹配，当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了！所以如何记录已经匹配的文本内容，是KMP的重点，也是next数组肩负的重任。

前缀表

next数组就是一个前缀表（prefix table）。

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

前缀表的作用：用来回退，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。

也就是说，前缀表的任务是当前位置匹配失败，找到之前已经匹配上的位置，再重新匹配，此也意味着在某个字符失配时，前缀表会告诉你下一步匹配中，模式串应该跳到哪个位置。

最长公共前后缀

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

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

前缀表要求的就是相同前后缀的长度。

使用前缀表的原因（重中之重，帮助理解）

当前的搜索字符串的最长相等的前缀 和 后缀字符串是 子字符串aa ，因为找到了最长相等的前缀和后缀，匹配失败的位置是后缀子串的后面，那么我们找到与其相同的前缀的后面重新匹配就可以了。

所以前缀表具有告诉我们当前位置匹配失败，跳到之前已经匹配过的地方的能力。

前缀表与next数组

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

其实这并不涉及到KMP的原理，而是具体实现，next数组既可以就是前缀表，也可以是前缀表统一减一（右移一位，初始位置为-1）。实际写代码的情况下，全部右移写起来简单很多，严格按照定义，写代码的时候就会有一些小细节容易忘记。

构造next数组

这里我就直接把带注释的代码拉过来了：

void getNext(int* next, const string& s){
    int j = -1;
    next[0] = j;
    for(int i = 1; i < s.size(); i++) { // 注意i从1开始
        while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
            j = next[j]; // 向前回退
        }
        if (s[i] == s[j + 1]) { // 找到相同的前后缀
            j++;
        }
        next[i] = j; // 将j（前缀的长度）赋给next[i]
    }
}

使用next数组来做匹配

还是直接把代码拉过来，其中s是待匹配字符串，而t是模版字符串：

int j = -1; // 因为next数组里记录的起始位置为-1
for (int i = 0; i < s.size(); i++) { // 注意i就从0开始
    while(j >= 0 && s[i] != t[j + 1]) { // 不匹配
        j = next[j]; // j 寻找之前匹配的位置
    }
    if (s[i] == t[j + 1]) { // 匹配，j和i同时向后移动
        j++; // i的增加在for循环里
    }
    if (j == (t.size() - 1) ) { // 文本串s里出现了模式串t
        return (i - t.size() + 1);
    }
}

例题28（简单）找出字符串中第一个匹配项的下标

注意要点：

  1. 就是直接使用KMP算法进行匹配就可以了。

下面贴出代码：

CPP版本

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;
        }
    }

    int strStr(string haystack, string needle) {
        if (!needle.size()) {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;
    }
};

C版本

void getNext(int* next, const char* s)
{
    int j = -1;
    next[0] = j;
    for (int i = 1; i < strlen(s); i++)
    {
        // 前后缀不同
        while (j >= 0 && s[i] != s[j + 1]) {j = next[j];}
        if (s[i] == s[j + 1]) {j++;}
        next[i] = j;
    }
}

int strStr(char * haystack, char * needle){
    if (!strlen(needle)) {return 0;}
    int next[strlen(needle)];
    getNext(next, needle);

    int j = -1;
    for (int i = 0; i < strlen(haystack); i++)
    {
        while (j >= 0 && haystack[i] != needle[j + 1]) {j = next[j];}
        if (haystack[i] == needle[j + 1]) {j++;}
        if (j == strlen(needle) - 1)
        {
            return i - strlen(needle) + 1;
        }
    }
    return -1;
}

例题459（简单）重复的子字符串

注意要点：

  1. 不使用KMP，可以直接复制两个字符串数组，然后掐头去尾，在其中判断是否有原字符串即可；
  2. 使用KMP，重复子字符串就是原字符串-最长相等前后缀。

下面贴出代码：

CPP版本

class Solution {
public:
    void getNext (int* next, const string& s)
    {
        next[0] = -1;
        int j = -1;
        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()) {return 0;}
        int next[s.size()];
        getNext(next, s);
        int len = s.size();
        if (next[len - 1] != -1 && !(len % (len - (next[len - 1] + 1)))) {return 1;}
        return 0;
    }
};

C版本

void getNext(int* next, const char* s)
{
    int j = -1;
    next[0] = j;
    for (int i = 1; i < strlen(s); i++)
    {
        while (j >= 0 && s[i] != s[j + 1]) {j = next[j];}
        if (s[i] == s[j + 1]) {j++;}
        next[i] = j;
    }
}

bool repeatedSubstringPattern(char * s){
    int* next = (int* )malloc(sizeof(int) * strlen(s));
    getNext(next, s);
    int len = strlen(s);
    if (next[len - 1] != -1 && !(len % (len - (next[len - 1] + 1)))) {return 1;} 
    return 0;
}

总结

  1. 字符串的题目大多涉及翻转，使用C++就可以直接用库函数reverse()完成操作，C只能自己苦哈哈的去for循环交换；
  2. 翻转单词等的操作，都可以采用整体+局部的两次翻转实现；
  3. 如果题目有设计删除操作，可以考虑快慢指针；
  4. KMP算法，只能死记硬背，而且之后没有涉及，就在字符串这边出现了一下。
秋招offer快来吧
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
代码随想录刷题学习笔记——初级篇C++/Python
never_stop_rain的博客
07-29 1287
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。来源：力扣（LeetCode）时间复杂度要求—>二分法查找返回两个坐标位置—>二分法分别查找左右边界分析返回的状态：1) [-1,-1]；
代码随想录刷题笔记1——数组
xhj12138的博客
09-02 182
代码随想录刷题笔记
跟着代码随想录之字符串
qq_42987423的博客
05-19 299
string类型在c++中使用时，需要加上头文件 #include < string > using std::string; 拷贝初始 string s = “value”; 直接初始化 string s(“value”); string:size_type() 类型？？？？ 反转字符串 使用前后指针，两边交换 class Solution { public: void reverseString(vector<char>& s) { i
代码随想录刷题笔记(数组)
自用笔记, 记录学习历程
03-06 731
数组1. 二分查找2. 移除元素3.有序数组的平方 1. 二分查找 代码随想录链接 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。假设 nums 中的所有元素是不重复的 public static int binarySearch(int[] nums, int target) { //先确定查找的元素是否在数组范围里 if (target &
代码随想录+刷题笔记记录
03-22
本文主要介绍代码随想录的刷题笔记记录，方便读者更好地利用该网站进行学习。 ## 刷题笔记记录的作用 刷题笔记记录是代码随想录提供的一个功能，用于记录用户在刷题过程中的解题思路和方法。它可以帮助用户更好地...
《代码随想录 刷题顺序》
weixin_44779122的博客
06-18 1188
704. 二分查找 27. 移除元素 209. 长度最小的子数组 59. 螺旋矩阵II203. 移除链表元素 707. 设计链表 206. 反转链表 19. 删除链表的倒数第N个结点242. 有效的字母异位词 349. 两个数组的交集 1. 两数之和 454. 四数相加II 15. 三数之和 18. 四数之和344. 整数拆分 541. 反转字符串II 151. 反转字符串中的单词 28. 找出字符串中第一个匹配项的下标 459. 重复的子字符串232. 用栈实现队列 225. 用队列实现栈 20. 有效的
代码随想录刷题打卡day02
04-18
LeetCode 是一个编程面试准备网站，提供了许多编程题目供用户练习，题目覆盖数组、字符串、链表、树、图等多种数据结构和算法。 8. 代码实现与测试：文档中包含了完整的方法实现，例如 `sortedSquares` 方法用于...
代码随想录-力扣刷题-总结笔记01
upward
02-27 1046
代码随想录-力扣刷题-总结笔记01
代码随想录刷题——组合问题专题篇
qq_35754976的博客
04-09 910
博主个人博客网站：文客 这个系列主要记录着对于代码随想录上面题目的题解和理解 如果你想每天和我一起刷题，可以关注一下我的个人博客网站：文客，我会每天在这里更新技术文章和面试题，也会及时收到大家的评论与留言，欢迎各位大佬来交流！ 77.组合 给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。 你可以按 任何顺序 返回答案。 示例 1： 输入：n = 4, k = 2 输出： [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4
算法的学习笔记—连续子数组的最大和
业精于勤，荒于嬉
08-29 3711
通过上述的动态规划方法，我们能够有效地解决连续子数组的最大和问题。该方法简单易懂，并且具有较高的效率，适合在大多数情况下使用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😁如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🤞。
12306项目学习笔记（框架篇Base）
qq_74851649的博客
08-30 1115
首先学习的是基础框架提供了一种静态方式来访问Spring容器中的Bean，适用于某些特定场景，如工具类和框架集成。在12306项目中由于我们引入了RocketMQ消息队列，这些库的对象通常不是Spring管理的，无法直接使用@Autowired注入，所以需要类提供一种静态方式来访问Spring容器中的Bean。比如在我们的TicketServiceImpl中的bean对象就是用以下方法获取的。
Datawhale X 李宏毅苹果书AI夏令营 学习笔记
m0_61049596的博客
08-31 918
今天，我继续学习了深度学习中的优化算法，并且着重理解了如何利用。等高级优化器来提高模型训练的效率和效果。2024年8月30日。
谷粒商城实战笔记-282~283-商城业务-订单服务-提交订单的问题
epitomizelu的专栏
08-29 1160
Services Panel 是 IntelliJ IDEA 提供的一个功能模块，旨在帮助开发者更好地管理和监控应用程序中的服务组件。它位于 IDE 的右侧面板中，可以方便地访问一系列与项目相关的服务和工具。
算法的学习笔记—把数字翻译成字符串
业精于勤，荒于嬉
08-31 917
通过动态规划的方法，我们可以高效地计算出一个数字字符串有多少种不同的翻译方法。这个问题不仅考察了我们对动态规划的理解，还让我们熟悉了如何处理字符串中的边界情况和状态转移。希望通过这个例子的讲解，能够帮助你更好地理解动态规划的应用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybit欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论
android - 笔记
tianyu的专栏 - Linux site:blog.csdn.net/wishfly
08-29 105
1 安装[教程]VMware安装Android虚拟机+联网_哔哩哔哩_bilibili
#C++ 笔记三
weixin_58298518的博客
08-29 1114
异常处理 智能指针 其他
深度学习入门笔记
本人hexo博客：www.boluoboluobo.top
08-29 849
个人感觉其实神经网络其实就是一个万能的拟合器，训练神经网络的过程，就是让计算机自己从大量的数据中寻找一条公式。这些数据有输入，输出结果，就是中间的函数映射是未知的，寻找的就是这些未知的映射。我们创建的神经网络，就是假定了函数的很多参数，通过损失函数，丈量与实际真实结果之间的距离。目标就是缩小之间的距离，而这个过程就相当于寻求一个函数的最低点，最低点的特征是导数为0，因此反向传播求导是获取了探寻最低点的方向，学习率就是前进的步长。
【扇贝编程】使用Selenium模拟浏览器获取动态内容笔记
最新发布
m0_73676887的博客
09-03 1429
文章目录selenium安装 selenium下载浏览器驱动获取数据处理数据查找一个元素查找所有符合条件的元素控制浏览器 selenium selenium是爬虫的好帮手， 可以控制你的浏览器，模仿人浏览网页，从而获取数据，自动操作等。 我们只要让 selenium 自动控制浏览器，实现爬取数据、自动抢票…… selenium要打开浏览器并控制它，占用的资源会更多，爬取数据的效率也会有所降低。 安装 selenium pip install selenium 下载浏览器驱动 根据你使用的浏览器（如 Chr
牛客上代码随想录怎么看题刷题
04-12
牛客网上的代码随想录是一个非常好的刷题平台，它提供了大量的编程题目和解题思路。在牛客网上刷题，可以按照以下步骤进行： 1. 注册并登录牛客网账号。 2. 在主页上找到“代码随想录”板块，点击进入。 3. 在代码...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值