一、344.反转字符串
题目链接:344. 反转字符串 - 力扣(LeetCode)
这道题相等于手写C++里的一个库函数 reverse
我的思路:
class Solution { public: void reverseString(vector<char>& s) { int total=s.size(); int front=0; int back=total-1; for(int i=total/2;i>=0;i--) { char temp; temp=s[front]; s[front]=s[back]; s[back]=temp; front++; back--; } } };
发现是在接近中间部分的时候翻转结果不符合答案,所以我想应该是边界条件没有把握好——》然后发现for循环里面的结束条件应该是i>=1而不是i>=0(其实这个边界在我写的时候我也不确定,只是觉得应该先把思路写完再去判断边界,结果就忘记了——》以后写的时候不确定的地方要加注释!!)
修改后就正确了:
class Solution { public: void reverseString(vector<char>& s) { int total=s.size(); int front=0; int back=total-1; for(int i=total/2;i>=1;i--) { char temp; temp=s[front]; s[front]=s[back]; s[back]=temp; front++; back--; } } };
卡子哥答案:和我的思路一样,直接代码写的更简洁了一点
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]); } } };
二、541. 反转字符串II
题目链接:541. 反转字符串 II - 力扣(LeetCode)
这道题目其实也是模拟,实现题目中规定的反转规则就可以了。
我的思路:思路不是就和上一题一样,只不过每次都需要判断剩余字符的数量
class Solution {//我这里写的是伪代码,毕竟目前重点是对比思路上的不同 public: string reverseStr(string s, int k) { int total=s.size(); int cur=0;//用来记录每次取出2k个数后,剩余数组成的数组的第一个元素的位置 for(;total>0;) { if(total<=k){ //全部翻转 total=0; } else if(total<=2*k && total>k){ //将前k个值翻转 total=0; } else{ //先计数,取出字符串中前2k个数,然后将前k个数进行翻转 total-=2*k; cur+=2*k; } } } };
卡子哥的思路:在遍历字符串的过程中,只要让 i += (2 * k),i 每次移动 2 * k 就可以了,然后判断是否需要有反转的区间。因为要找的也就是每2 * k 区间的起点,这样写,程序会高效很多。
1.和我一样,只不过他把剩余数组的元素个数大于2k的情况 与 剩余数组元素个数大于k小于2k的情况结合了起来,让代码更简洁了
2.此外,他还用了内置的reverse()函数——注意,reverse函数不是string的成员函数,而是一个通用的库函数。
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; } };
三、剑指Offer 05.替换空格
题目链接:力扣
1.我的思路:
新开一个数组;一个指针i指向原数组,一个指针j指向新开的数组;当遇到空格时,在新数组中加入"%20"这三个字符;其他情况下将原数组中的字符原封不动的复制到新数组中。
代码实现时的疑问:一开始如何确定存储字符串的数组的大小要设为几?——》因为题目给了条件是:字符串s的长度<=10000,所以我设一个长度为30000的数组肯定没有问题。但是有点浪费,因为我设的是最坏情况下数组需要的大小。——》看完卡子哥的代码,我发现s的内容传入以后就固定了,所以我们可以计算出这个字符串s里面有多少个空格,然后就对应扩容多少空间。
2.卡子哥思路:
如果想把这道题目做到极致,就不要使用额外的辅助空间了!
首先扩充数组到每个空格替换成"%20"之后的大小。然后从后向前替换空格,也就是双指针法,过程如下:i指向新长度的末尾,j指向旧长度的末尾。
问题(重点):为什么要从后向前填充,从前向后填充不行么?
从前向后填充就是O(n^2)的算法了,因为每次添加元素都要将添加元素之后的所有元素向后移动。
其实很多数组填充类的问题,都可以先预先给数组扩容待填充后的大小,然后在从后向前进行操作。
这么做有两个好处:
-
不用申请新数组。
-
从后向前填充元素,避免了从前向后填充元素时,每次添加元素都要将添加元素之后的所有元素向后移动的问题。(关键)
我的缺点:给数组扩容的方式有些遗忘——》其实看了卡子哥的思路的时候我觉得我有所遗忘,原因是以前用c语言写数据结构的时候,数组扩容就是申请一个更大的内存空间,如何把数组现有的数值复制进去,然后把原数组释放掉。所以我觉得这好像还是使用了额外的辅助空间。——》但看了卡子哥的代码后发现,那样不算是使用了额外空间;虽然卡子哥使用了string的类内函数resize(),但是这个resize()的源码肯定也是用重新申请一个空间更大的数组的方式来扩容。
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--) {//j=i的时候就会退出循环--这时j和i都达到了字符串的最左边 if (s[j] != ' ') { s[i] = s[j]; } else { s[i] = '0'; s[i - 1] = '2'; s[i - 2] = '%'; i -= 2; } } return s; } };
-
时间复杂度:O(n)
-
空间复杂度:O(1)
此时算上本题,我们已经做了七道双指针相关的题目了分别是:
字符串和数组的区别
字符串是若干字符组成的有限序列,也可以理解为是一个字符数组,但是很多语言对字符串做了特殊的规定,接下来我来说一说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< char > 和 string 又有什么区别呢?
其实在基本操作上没有区别,但是 string提供更多的字符串处理的相关接口,例如string 重载了+,而vector却没有。所以想处理字符串,我们还是会定义一个string类型
四、151.翻转字符串里的单词(难)
原题链接;151. 反转字符串中的单词 - 力扣(LeetCode)
给定一个字符串,逐个翻转字符串中的每个单词。
注意:我感觉卡子哥是把string前后只能有一个空格来处理了!那我就这样认为就行了,可能是因为他已经研究过这道题力扣里面的数据集了。
示例 1: 输入: "the sky is blue" 输出: "blue is sky the" 示例 2: 输入: " hello world! " 输出: "world! hello" 解释: 输入字符串可以在前面或者后面包含多余的空格,但是反转后的字符不能包括。 示例 3: 输入: "a good example" 输出: "example good a" 解释: 如果两个单词间有多余的空格,将反转后单词间的空格减少到只含一个
1.我的想法:我想不出来要怎么翻转单词,因为这道题中单词内部的顺序是不需要翻转的,但上面的翻转的题目都是将一整个string全部翻转,所以我就是没有这个的思路。
2.卡子哥提到的思路:
(1)使用split库函数,分隔单词,然后定义一个新的string字符串,最后再把单词倒序相加——》但是这样的话这道题目就是一道水题了,失去了它的意义。
提高一下本题的难度:不要使用辅助空间,空间复杂度要求为O(1)。
(2)(重要)我们将整个字符串都反转过来,那么单词的顺序指定是倒序了,只不过单词本身也倒序了,那么再把单词反转一下,单词不就正过来了。
所以解题思路如下:
-
移除多余空格
-
将整个字符串反转
-
将每个单词反转
这样我们就完成了翻转字符串里的单词。
3.代码细节:
注意:我感觉卡子哥是把string前后只能有一个空格来处理了!那我就这样认为就行了,可能是因为他已经研究过这道题力扣里面的数据集了。
(1)移除空格
方法一(bad):
就拿移除多余空格来说,一些同学会上来写如下代码:
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] == ' ') {//其实我觉得这里用while更合适,除非规定 每个string前面和后面只会有有一个空格 s.erase(s.begin() + s.size() - 1); } // 删除字符串最前面的空格 if (s.size() > 0 && s[0] == ' ') { s.erase(s.begin()); } }
逻辑很简单,从前向后遍历,遇到空格了就erase。
如果不仔细琢磨一下erase的时间复杂度,还以为以上的代码是O(n)的时间复杂度呢。
想一下真正的时间复杂度是多少,一个erase本来就是O(n)的操作。
erase操作上面还套了一个for循环,那么以上代码移除冗余空格的代码时间复杂度为O(n^2)。
方法二:双指针(good)
那么使用双指针法来去移除空格,最后resize(重新设置)一下字符串的大小,就可以做到O(n)的时间复杂度。
//版本一 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); // 重新设置字符串大小 } }
“快慢指针”去除空格的思路:快指针就是快速经过空格位置不停留,直到找到了字符,才停留并召唤slow指针来获取字符。
有的同学可能发现用erase来移除空格,在leetcode上性能也还行。主要是以下几点;:
-
leetcode上的测试集里,字符串的长度不够长,如果足够长,性能差距会非常明显。
-
leetcode的测程序耗时不是很准确的。
版本一的代码是一般的思考过程,就是 先移除字符串前的空格,再移除中间的,再移除后面部分。
不过其实还可以优化,这部分和27.移除元素 (opens new window)的逻辑是一样一样的,本题是移除空格,而 27.移除元素 就是移除元素,两道题目都可以使用“双指针法”。
所以代码可以写的很精简,大家可以看 如下 代码 removeExtraSpaces 函数的实现:
// 版本二 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++];//这里i++后若退出了while循环,说明i++后对应的元素为空格;然后最外层for循环又会进行++i,这样就能跳到空格的下一个字符了。(小细节--妙) } } } s.resize(slow); //slow的大小即为去除多余空格后的大小。 }
此时我们已经实现了removeExtraSpaces函数来移除冗余空格。
还要实现反转字符串的功能,支持反转字符串子区间,这个实现我们分别在344.反转字符串 (opens new window)和541.反转字符串II (opens new window)里已经讲过了。
代码如下:
// 反转字符串s中左闭右闭的区间[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]); } }
整体代码如下:
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(n)
-
空间复杂度: O(1) 或 O(n),取决于语言中字符串是否可变
本题思路中最独特的地方就是“整体反转+局部反转”
五、剑指Offer58-II.左旋转字符串
题目链接:力扣
我的思路:把数组头部的元素运到数组尾部
class Solution { public: string reverseLeftWords(string s, int n) { int end=s.size()-1; for(int i=0;i<n;i++) { //把数组中前n个数字另开一个数组nums把里面的值给记录下来 } for(){ //把数组中n个以外的数组往前移动 } for(){ //再把nums数组中的元素放到原数组的后面 } } };
卡子哥思路:
为了让本题更有意义,提升一下本题难度:不能申请额外空间,只能在本串上操作。
不能使用额外空间的话,模拟在本串操作要实现左旋转字符串的功能还是有点困难的。
那么我们可以想一下上一题目字符串:花式反转还不够! (opens new window)中讲过,使用整体反转+局部反转就可以实现反转单词顺序的目的。
这道题目也非常类似,依然可以通过局部反转+整体反转 达到左旋转的目的(精髓)。
具体步骤为:
-
反转区间为前n的子串
-
反转区间为n到末尾的子串
-
反转整个字符串
最后就可以达到左旋n的目的,而不用定义新的字符串,完全在本串上操作。
例如 :示例1中 输入:字符串abcdefg,n=2
最终得到左旋2个单元的字符串:cdefgab
思路明确之后,那么代码实现就很简单了
C++代码如下:
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; } };
-
时间复杂度: O(n)
-
空间复杂度:O(1)