代码随想录第八天 | 字符串的反转（leetcode 344，541，151，剑指Offer58-II），替换字符串中字符（剑指Offer 05）

已于 2024-03-30 17:22:57 修改
阅读量70 收藏
点赞数 1
分类专栏： leetcode c++ 文章标签： leetcode 算法 c++ 数据结构
于 2023-08-20 16:10:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AsherGu/article/details/132392217
版权

1、字符串的反转

1.1 leetcode 344：双指针

双指针两边往中间移动的同时，进行元素互换

第一遍代码

class Solution {
public:
    void reverseString(vector<char>& s) {
    //双指针两边往中间互换
        int start = 0;
        int end = s.size() - 1;
        while(start <= end) {
            char tmp;
            tmp = s[start];
            s[start] = s[end];
            s[end] = tmp;
            start++;//别忘了
            end--;
        }
    }
};

使用库函数（如果库函数仅仅是解题过程中的一小部分，并且你已经很清楚这个库函数的内部实现原理的话，可以考虑使用库函数）

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

1.2 leetcode 541：固定规律一段一段去处理字符串

第一遍代码

class Solution {
public:
    string reverseStr(string s, int k) {
        int start = 0;
        int end = 0;
        while(start < s.size()) {
            if(start + k - 1 > s.size() - 1) { //少于k也要反转
                end = s.size() - 1;
            }
            else {
                end = start + k - 1;
            }
            for(int i = start, j = end; i <= j; i++, j--) {
                swap(s[i], s[j]);
            }
            start += 2*k; 
        }
        return s;
    }
};

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

当需要固定规律一段一段去处理字符串的时候，要想想在在for循环的表达式上做做文章

具体反转的逻辑我们要不要使用库函数呢，其实用不用都可以，使用reverse来实现反转也没毛病，毕竟不是解题关键部分

另一种实现

class Solution {
public:
    string reverseStr(string s, int k) {
        for (int i = 0; i < s.size(); i += (2 * k)) {
            // 1. 每隔 2k 个字符的前 k 个字符进行反转
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            if (i + k <= s.size()) {
                reverse(s.begin() + i, s.begin() + i + k );
            } else {
                // 3. 剩余字符少于 k 个，则将剩余字符全部反转。
                reverse(s.begin() + i, s.end());
            }
        }
        return s;
    }
};

只用一个指针也行，就是要 运算结尾位置

class Solution {
public:
    string reverseStr(string s, int k) {
        for (int i = 0; i < s.size(); i += 2*k) {
            int bond = i + k;
            if (bond > s.size())
                bond = s.size();
            for (int j = i; j < i + (bond - i) / 2; j++) {
                swap(s[j], s[bond - (j - i + 1)]); // 注意下标的运算
            }
        }
        return s;
    }
};

1.3 leetcode 151：双指针去空格+整体反转加局部反转

使用开始 / 结束 两个下标 完成单词的分割，从后往前

class Solution {
public:
    string reverseWords(string s) {
        //从后往前每一个单词都使用双指针搬到新的字符串内
        string result;
        int end = s.size() - 1;//标记每个单词的末位
        while(s[end] == ' ') {//去掉前后空格
            end--;
        }
        int start = end;//标记每个单词的开始，从后往前加入result
        int st = 0;
        while(s[st] == ' ') {
            st++;
        }
        int count = 1;//点清单词之间的空格数
        while(start >= st) {
            if(s[start] != ' ') {
                start--;
            }
            else {
                if(s[start - 1] == s[start]) {
                    start--;
                    count++;
                }
                else {
                    for(int i = start + count; i <= end; i++) {
                        result += s[i];
                    }
                    result += s[start--];
                    count = 1;//count回到1
                    end = start;//end别忘了动
                }
            }
        }
        //把最后一个单词填进去，因为第一个单词前没有空格
        for(int i = start + count; i <= end; i++) {
            result += s[i];
        }
        return result;
    }
};

使用开始 / 结束 两个迭代器 完成单词的分割，从前往后

class Solution {
public:
    string reverseWords(string s) {
        auto en = s.begin();
        auto be = s.begin();
        string ss;
        for (auto it = s.begin(); it <= s.end(); it++) {
            if (*it != ' ' && it != s.end()) { // it为s.end()也需要分割单词
                continue;
            }
            else {
                if (it != s.begin() && *(it-1) == ' ') { // ''与' '还是不同的，一个空的，一个空格字符
                    be++;
                    continue;
                }
                en = it;
                string tmp(be, en); // string初始化时 en指针指向结尾的下一位置，即空字符
                if (!ss.empty()) {
                    string tmp2 = tmp + " " + ss;
                    ss = tmp2;
                }
                else {
                    string tmp2 = tmp + ss;
                    ss = tmp2;
                }
                be = it + 1;
            }
        }
        return ss;
    }
};

报错erminate called after throwing an instance of ‘std::length_error’ what(): basic_string::_M_create：有string时可能最后 没有加空格

代码随想录思路

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

所以解题思路如下：

1、移除多余空格
2、将整个字符串反转
3、将每个单词反转

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

移除多余空格 : “the sky is blue”
字符串反转：“eulb si yks eht”
单词反转：“blue is sky the”
这样我们就完成了翻转字符串里的单词

双指针移除多余空格来说，如下代码

void removeExtraSpaces(string& s) {
    for (int i = s.size() - 1; i > 0; i--) {
        if (s[i] == s[i - 1] && s[i] == ' ') {
            s.erase(s.begin() + i);
        }
    }
    // 删除字符串最后面的空格
    if (s.size() > 0 && s[s.size() - 1] == ' ') {//要确保s.size()-1合法
        s.erase(s.begin() + s.size() - 1);
    }
    // 删除字符串最前面的空格
    if (s.size() > 0 && s[0] == ' ') {
        s.erase(s.begin());
    }
}

不仔细琢磨一下erase的时间复杂度，还以为以上的代码是O(n)的时间复杂度
真正的时间复杂度是多少，一个erase本来就是O(n)的操作
erase操作上面还套了一个for循环，那么以上代码移除冗余空格的代码时间复杂度为O(n2)

使用双指针法来去移除空格，最后resize（重新设置）一下字符串的大小，就可以做到O(n)的时间复杂度

slowIndex为目标位置，fastIndex为目标元素位置，同leetcode 27

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 - 1] == s[fastIndex]
                && s[fastIndex] == ' ') {
            continue;
        } else {
            s[slowIndex++] = s[fastIndex];
        }
    }
    if (slowIndex - 1 > 0 && s[slowIndex - 1] == ' ') { // 去掉字符串末尾的空格
        s.resize(slowIndex - 1);
    } else {
        s.resize(slowIndex); // 重新设置字符串大小
    }
}
void removeExtraSpaces(string& s) {//去除所有空格并在相邻单词之间添加空格, 快慢指针
    int slow = 0;   //i为快指针，slow为慢指针
    for (int i = 0; i < s.size(); ++i) { //
        if (s[i] != ' ') { //遇到非空格就处理，即删除所有空格，遇到空格直接啥都不干i++
            if (slow != 0) s[slow++] = ' '; //手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。
            while (i < s.size() && s[i] != ' ') { //补上该单词，遇到空格说明单词结束。展现对for循环的理解
                s[slow++] = s[i++];
            }
        }
    }
    s.resize(slow); //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;   //整体思想参考leetcode 27
        for (int i = 0; i < s.size(); ++i) { //
            if (s[i] != ' ') { //遇到非空格就处理，即删除所有空格。
                if (slow != 0) s[slow++] = ' '; //手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。一定要写在后面那个添加单词的前面
                while (i < s.size() && s[i] != ' ') { //补上该单词，遇到空格说明单词结束，展现对for循环的理解
                    s[slow++] = s[i++];
                }
            }
        }
        s.resize(slow); //slow的大小即为去除多余空格后的大小。
    }

    string reverseWords(string s) {
        removeExtraSpaces(s); //去除多余空格，保证单词之间之只有一个空格，且字符串首尾没空格。
        reverse(s, 0, s.size() - 1);
        int start = 0; //removeExtraSpaces后保证第一个单词的开始下标一定是0。
        for (int i = 0; i <= s.size(); ++i) {
            if (i == s.size() || s[i] == ' ') { //到达空格或者串尾，说明一个单词结束。进行翻转。
                reverse(s, start, i - 1); //翻转，注意是左闭右闭 []的翻转。
                start = i + 1; //更新下一个单词的开始下标start
            }
        }
        return s;
    }
};

1.4 剑指Offer58-II：反转两个子串加整体反转

剑指offer的题目是左反转，下面链接是 右旋转

卡码网 题目链接

其实思路是一样一样的，就是反转的区间 和 顺序不同而已
以 翻转区间相同 顺序不同为例：
初始状态
右移n位， 就是将第二段放在前面，第一段放在后面，先不考虑里面字符的顺序，是不是整体倒叙不就行了。如图：
整体倒叙
此时第一段和第二段的顺序是我们想要的，但里面的字符位置被我们倒叙，那么此时我们在把 第一段和第二段里面的字符再倒叙一把，这样字符顺序不就正确了
第一段和第二段里面的字符再倒叙

reverse(s.begin(), s.end()); // 整体反转
reverse(s.begin(), s.begin() + n); // 先反转前一段，长度n
reverse(s.begin() + n, s.end()); // 再反转后一段

当然 也可以使用 下面一样的翻转顺序，那反转区间就不同了

reverse(s.begin(), s.begin() + len - n); // 先反转前一段，长度len-n ，注意这里是和版本一的区别
reverse(s.begin() + len - n, s.end()); // 再反转后一段
reverse(s.begin(), s.end()); // 整体反转

剑指Offer58-II：题目链接 就改了个变量名

class Solution {
public:
    string reverseLeftWords(string s, int n) {
       string result;
       for(int i = n; i < s.size(); i++) {
           result += s[i];
       }
       for(int i = 0; i < n; i++) {
           result += s[i];
       }
       return result;
    }
};

为了让本题更有意义，提升一下本题难度：不能申请额外空间，只能在本串上操作

不能使用额外空间，模拟在本串操作实现左旋转字符串的功能：

使用上一题（leetcode 151）中的思路，使用整体反转+局部反转就可以实现反转单词顺序的目的。
这道题目也非常类似，依然可以通过局部反转+整体反转达到左旋转的目的

具体步骤为：
1、反转区间为前n的子串
2、反转区间为n到末尾的子串
3、反转整个字符串

最后就可以达到左旋n的目的，而不用定义新的字符串，完全在本串上操作

例如 ： 输入：字符串abcdefg，n=2

剑指OFFER58-II 思路

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

先整体反转再局部反转是一个很妙的思路

2、替换字符串中字符

2.1 剑指Offer 05：数组填充类：从后向前进行操作

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

第一遍代码

class Solution {
public:
    string replaceSpace(string s) {
        int count = 0;//统计出有多少空格以便设置快指针从后往前移动
        for(int i = 0; i < s.size(); i++) {
            if(s[i] == ' ') {//空格字符一定用单引号括起来
               count++;
            }
        }
        int slow = s.size() - 1;
        int newsize = count*2 + s.size();
        s.resize(newsize);
        int fast = newsize - 1;
        while(fast >= 0) {
            if(s[slow] != ' ') {
                s[fast] = s[slow];
                fast--;
                slow--;
            }
            else {
                s[fast--] = '0';
                s[fast--] = '2';
                s[fast--] = '%';
                slow--;
            }
        }
        return s;
    }
};

从前向后填充就是O(n2)的算法了，因为每次添加元素都要将添加元素之后的所有元素向后移动（因为变长了）

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

这么做有两个好处：
1、不用申请新数组
2、从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题

2.2 字符串和数组/vector差别

字符串是若干字符组成的有限序列，也可以理解为是一个字符数组，但是很多语言对字符串做了特殊的规定，接下来我来说一说C/C++中的字符串

在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 和 string 区别：
其实在基本操作上没有区别，但是string提供更多的字符串处理的相关接口，例如string重载了+，而vector却没有
所以想处理字符串，我们还是会定义一个string类型

Asher Gu
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
AlgorithmAndLeetCode#itcharge-LeetCode-Py#剑指 Offer 32 - II. 从上到下
07-25
要求：从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。依次从队列中取出这 $s_i$ 个元素，并将其左右子节点入队，遍历完之后将这层
Java实现 LeetCode 541 反转字符串 II（暴力大法）
12-21
在LeetCode的541题“反转字符串II”中，主要任务是实现一个函数，根据给定的整数k对字符串进行特定的反转操作。题目要求对于字符串s的每一个长度为2k的子串，反转前k个字符。如果剩余字符不足k个，那么反转所有剩余...
Rogerspy#LeetCode-Py-1#剑指 Offer II 016. 不含重复字符的最长子字符串1
07-25
剑指 Offer II 016. 不含重复字符的最长子字符串标签：哈希表、字符串、滑动数组难度：中等题目大意给定一个字符串 s。遍历字符串，右指针不断右移，利用
算法修炼之路—【字符串】Leetcode 345 反转字符串中的元音字母
12-20
在算法修炼之路上，我们经常会遇到各种有趣的编程挑战，其中之一便是LeetCode的第345题——反转字符串中的元音字母。本题目的目标是设计一个函数，接收一个字符串作为输入，然后仅反转其中的元音字母。元音字母包括...
LeetCode判断字符串是否循环-AC_Offer:剑指Offer刷题Java代码
07-01
LeetCode判断字符串是否循环 面试必刷《剑指Offer》-- 上 总所周知，不论你是面试Java/C++/C...的岗位，算法是鉴定一个人基础的重要指标，良好的算法基础也是你能通过笔试的必要条件。剑指Offer是众多企业历年招聘的...
力扣220题详解：存在重复元素 III 的多种解法与复杂度分析
10年数据\经营分析经验，现任大厂数据分析负责人
08-21 666
本文详细解读了力扣第220题“存在重复元素 III”，通过使用滑动窗口 + 桶排序和滑动窗口 + 有序集合两种方法高效地解决了这一问题，并提供了详细的解释和模拟面试问答。希望读者通过本文的学习，能够在力扣刷题的过程中更加得心应手。
一起学习LeetCode热题100道（48/100）
weixin_53224223的博客
08-20 534
7.注意：虽然代码中包含了回溯部分（即减少当前路径和的计数并从prefixSums中删除它），但在本问题中，由于树是无环的，并且我们不需要精确跟踪每条路径，因此这部分是多余的。输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22。输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8。1.这是主函数，接收根节点和目标和作为参数，并返回满足条件的路径数量。
Leetcode 219. 存在重复元素 II⭐️
铁马冰河入梦来
08-20 417
哈希表解决存在重复元素二问题
Leetcode面试经典150题-128.最长连续序列
个人专长：数据结构和算法、大数据、数据库、主流框架
08-23 291
Leetcode面试经典150题-128.最长连续序列，同时也是字节面试高频题频次第15高的题，务必掌握
力扣104 二叉树的最大深度
最新发布
gyj215500的博客
08-23 292
【代码】力扣104 二叉树的最大深度。
【Hot100】LeetCode—104. 二叉树的最大深度
weixin_44382896的博客
08-22 203
【代码】【Hot100】LeetCode—104. 二叉树的最大深度。
leetcode_62. 不同路径 + 63. 不同路径 II
m0_62593050的博客
08-20 1081
m x n网格的左上角到达右下角，每次只能向下或者向右移动一步。问总共有多少条不同的路径
【LeetCode每日一题】——1046.最后一块石头的重量
IronmanJay的博客
08-22 1008
有一堆石头，每块石头的重量都是正整数。 每一回合，从中选出两块 最重的 石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x
26.删除有序数组中的重复项---力扣
Auroral_0218的博客
08-21 457
- 力扣（LeetCode）. - 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。
leetcode118. 杨辉三角，老题又做
qq_51350957的博客
08-21 657
leetcode118. 杨辉三角，老题又做
【Hot100】LeetCode—94. 二叉树的中序遍历
weixin_44382896的博客
08-22 416
二叉树的处理遍历过程，主要分为两步。
力扣222题详解：完全二叉树的节点个数的多种解法与模拟面试
10年数据\经营分析经验，现任大厂数据分析负责人
08-21 692
本文详细解读了力扣第222题“完全二叉树的节点个数”，通过使用暴力法和利用完全二叉树特性的优化方法高效地解决了这一问题，并提供了详细的解释和模拟面试问答。希望读者通过本文的学习，能够在力扣刷题。
Leetcode 237.19.83.82 删除链表重复结点 C++实现
半跨考本科生的代码日常
08-22 482
不是链表中的最后一个节点。， 删除原始链表中所有重复数字的节点，只留下不同的数字。返回已排序的链表。， 删除所有重复的元素，使每个元素只出现一次。步，然后左右指针一起向右走，当右指针指向最后一个结点时，左指针。如果出现重复的结点，则用下一个结点覆盖它。问题：给你一个链表，删除链表的倒数第。存储重复出现的元素值，一旦有结点的值与。，我们想删除它其中的一个节点node。遇到相同元素值的结点，全部删除。给定一个已排序的链表的头head。给定一个已排序的链表的头head。个结点，并且返回链表的头结点。
leetcode326. 3 的幂，简单模拟
qq_51350957的博客
08-22 1002
leetcode326. 3 的幂，简单模拟
如何用reverse函数反转leetcode这个字符串
09-14
使用reverse函数反转leetcode字符串的方法是：将字符串作为参数传入reverse函数，然后将反转后的字符串返回给调用者。例如：let reversedString = reverse("leetcode")。 ### 回答2： 要使用reverse函数反转...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值