代码随想录算法训练DAY 8| 字符串：344.反转字符串、541. 反转字符串II、剑指Offer 05.替换空格、151.翻转字符串里的单词、剑指Offer58-II.左旋转字符串

最新推荐文章于 2024-11-14 21:21:03 发布

看天空的星云

最新推荐文章于 2024-11-14 21:21:03 发布

阅读量146

点赞数

文章标签：算法数据结构 c++

本文链接：https://blog.csdn.net/qq_43564036/article/details/130755353

版权

344.反转字符串

题目链接: link
在这里插入图片描述

C++库函数reverse:

这里先介绍一下C++自带的反转的库函数reverse：

常用于数组，字符串，容器等，其本身的函数参数也不复杂。
标准C中是没有recerse()函数的，这是C++的一个新增函数，使用需要包含头文件：#include
reverse函数用于反转在[first,last)范围内的顺序（包括first指向的元素，不包括last指向的元素），reverse函数没有返回值；

交换vector容器中元素的顺序：reverse(vector.begin(),vector.end());
string类的字符串:reverse(str.begin(),str.end());

class Solution {
public:
    void reverseString(vector<char>& s) {
        //如果使用库函数：
        reverse(s.begin(),s.end());
        return;
    }
};

双指针的解题过程：

因为本题要求不使用库函数，那么在本题，我们可以类比反转链表的思路，来反转字符串，唯一不同的是字符串用的是数组形式的容器来存储，在处理上是更为简单的；也是使用双指针
题目要求不分配额外空间，那么也都是在原数组的基础上来进行的操作。
两个指针，双指针从头和尾部进行交换并逐步向中间移动；

class Solution {
public:
    void reverseString(vector<char>& s) {
        // //如果使用库函数：
        // reverse(s.begin(),s.end());
        // return;
        int length = s.size();
        //写法二：for (int i = 0, j = s.size() - 1; i < s.size()/2; i++, j--)
        for(int left =0, right = length -1; left < right; left++, right--){
            swap (s[left], s[right]);
			//如果不使用swap函数的话，使用数值运算：
			//int temp = s[left];
            //s[left] = s[right];
            //s[right] = temp;
        }
        return;
    }
};

注：这里是可以使用swap的，因为题目并不能通过这个库函数直接就完成整个过程；那么便是可以使用的；

541. 反转字符串II

题目链接: link
在这里插入图片描述
其实在遍历字符串的过程中，只要让 i += (2 * k)，i 每次移动 2 * k 就可以了，然后判断是否需要有反转的区间。
一种典型的思路就是还是在for循环中进行i++；这样的话便会导致需要在循环中额外添加类似count的变量去记录每到2k个数时，需要进行一些额外的什么什么操作，会让代码更加复杂；

因为要找的也就是每2 * k 区间的起点，这样写，程序会高效很多。

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

class Solution {
public:
    string reverseStr(string s, int k) {
        for(int i=0; i < s.size() ; i += 2*k ){
            //reverse(s.begin() + i, s.begin() + min(i + k, n)); 
            
            //如果长度满足K个,反转这K个字符
            if(i+k <= s.size()){
                reverse (s.begin() + i, s.begin() + i +k);
            }
            else{//如果不满足K个元素,将剩余的全部反转
                reverse (s.begin() + i, s.end());
            }
        }
        return s;
    }
};

不使用官方reverse库函数，自己写交换函数的写法：

写一个实现的reverse函数区间是左闭右闭区间：
易错点：这里因为自己写的函数是首尾进行交换，因此也就会是s[i]; s[i+k-1]位置的一个交换，所以是i+k “-1 ”的一个区间

而原本库函数的reverse是左闭右开的，所有reverse（i，i+k）实际是i ~i+k-1的区间反转；

class Solution {
public:

    string reverseStr(string s, int k) {
        for(int i=0; i < s.size() ; i += 2*k ){
            //reverse(s.begin() + i, s.begin() + min(i + k, n)); 
            
            //如果长度满足K个,反转这K个字符
            if(i+k <= s.size()){
                //reverse (s.begin() + i, s.begin() + i +k);
                reverse_begin_end(s, i, i + k -1);
            }
            else{//如果不满足K个元素,将剩余的全部反转
                //reverse (s.begin() + i, s.end());
                reverse_begin_end(s, i , s.size() -1);
            }
        }
        return s;
    }

//写法二：编一个函数完成
    void reverse_begin_end (string& s, int start, int end){
        for(int i = start, j = end; i <j; i++,j--){
            //swap(s[i],s[j]);
            int temp = s[i];
            s[i] = s[j];
            s[j] = temp;
        }
    }

剑指Offer 05.替换空格

题目链接: link
在这里插入图片描述
在 C++ 语言中， string 被设计成「可变」的类型（参考资料），因此可以在不新建字符串的情况下实现原地修改。
（当然也可以重新建立一个数组字符串，然后遍历字符串依次向新数组内进行填充）

极致利用空间的方法：

不要只用额外的辅助空间了！

首先扩充数组到每个空格替换成"%20"之后的大小。然后从后向前替换空格，也就是双指针法：

为什么要从后向前填充，从前向后填充不行么？

从前向后填充就是O(n^2)的算法了，因为每次添加元素都要将添加元素之后的所有元素向后移动。

本题核心思想：！！！！！！！！！！！！！！！！！！
其实很多数组填充类的问题，都可以先预先给数组扩容带填充后的大小，然后在从后向前进行操作。

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

C++中resize函数使用：

resize()，设置大小;

reserve()，设置容量;

resize()是分配容器的内存大小，而reserve()只是设置容器容量大小，但并没有真正分配内存。

resize()可以传递两个参数，分别是大小和初始值，初始值默认为0，reserve()只能传递一个参数，不能设置初始值，其初始值为系统随机生成。
eg:
m.resize(10);
n.reserve(10);
s.resize(10, 6);

代码随想录代码：

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的大小，也就是每个空格替换成"%20"之后的大小
        s.resize(s.size() + count * 2);
        int sNewSize = s.size();
        // 从后先前将空格替换为"%20"
        for (int i = sNewSize - 1, j = sOldSize - 1; 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;

如果使用辅助空间：

        string temp;
        for (int i = 0; i < s.length(); i ++){
            if (s[i] == ' ') temp += "%20";
            else temp += s[i];
        }
        return temp;




//直接使用库函数：
        class Solution {
public:
    string replaceSpace(string s) {
        return s.replace(' ', "%20");
    }
};

补充：关于C++中的字符串，一般我们都用的string类；
字符串是若干字符组成的有限序列，也可以理解为是一个字符数组，
在C++中，提供一个string类，string类会提供 size接口，可以用来判断string类字符串是否结束，就不用’\0’来判断是否结束；

vector< char > 和 string 又有什么区别呢？

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

151.翻转字符串里的单词

链接: link
思路：
解题思路如下：

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

C++不像JAVA等，其当中没有split相关的库函数（当然博客上也有类似写出的函数来完成这种功能），做这种题我们也还是按照正常思路去一步步编写逻辑代码最好：

最好这里不要用erase操作来移除空格之类的，因为它本身上面还套了一个for循环，那么代码移除冗余空格的代码时间复杂度为O(n^2)，会显得很冗余和复杂了；

这里给出代码随想录的整体代码过程：

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;   //整体思想参考https://programmercarl.com/0027.移除元素.html
        for (int i = 0; i < s.size(); ++i) { //
            if (s[i] != ' ') { //遇到非空格就处理，即删除所有空格。
                if (slow != 0) s[slow++] = ' '; //手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。
                while (i < s.size() && s[i] != ' ') { //补上该单词，遇到空格说明单词结束。
                    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;
    }
};

双指针思想的另一种写法思路：（但空间复杂度不是O(1)了

使用了substr函数：
substr()是C++语言函数，主要功能是复制子字符串，要求从指定位置开始，并具有指定的长度。如果没有指定长度_Count或_Count+_Off超出了源字符串的长度，则子字符串将延续到源字符串的结尾。
形式： s.substr(pos, len)
返回值： string，包含s中从pos开始的len个字符的拷贝

class Solution {
public:
    string reverseWords(string s) {
        int i = s.size() - 1;
        string ans;
        while(i >= 0)
        {
            int c = 0;
            while(i >= 0 && s[i] == ' ') --i;
            while(i >= 0 && s[i] != ' ')
            {
                --i;
                ++c;
            }
            if(c)
                ans += s.substr(i+1, c) + " ";
        }

        return ans.substr(0, ans.size()-1);
    }
};

作者：小虎
链接：https://leetcode.cn/problems/reverse-words-in-a-string/solutions/682396/cyou-mei-jian-dan-dai-ma-by-xiaohu9527-imlc/
来源：力扣（LeetCode）

剑指Offer58-II.左旋转字符串

链接: link

巧解：先局部反转再整体反转，在原基础上做文章

这种想法主要是在思路上是否能够想到这样去应用！思路很难想到，但想到后的具体实现是更为简单的！

具体步骤为：

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

        reverse(s.begin(), s.begin() + n);
        reverse(s.begin() + n, s.end());
        reverse(s.begin(), s.end());
        return s;

如果使用额外空间:

方法一：

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

        }
        return temp;

    }
};

方法二：使用substr函数切片一段：
（substr函数的第二个参数是想截取的字符个数）

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