题目链接:反转字符串
参考:https://programmercarl.com/0344.%E5%8F%8D%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2.html
编写一个函数,其作用是将输入的字符串反转过来。输入字符串以字符数组 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"]
提示:
在反转链表中,用了双指针的方法,所以,反转字符串,仍然是用双指针的方法,只不过字符串的反转,要比链表更简单。因为字符串也是一种数组,所以元素在内存中是连续分布,这就决定了反转链表和反转字符串方式上还是有所差异的。
对于字符串,我们定义两个指针(也可以说是索引下标),一个从字符串前面,一个从字符串后面,两个指针同时向中间移动,并交换元素。
可以自己找一个字符串”hello“,模拟一下他的反转过程,对它的循环条件要理解清楚(奇数,偶数情况)。
//时间复杂度:O(n)
//空间复杂度:O(1)
void reverseString(vector<char>& s) {
for (int i = 0, j = s.size() - 1; i < s.size()/2; i++, j--) {
swap(s[i],s[j]);
}
}
时间复杂度: O(N)
两个指针一个从头往后,一个从后往前,直到他们相遇,总共会把长度为N的字符数组全部遍历一遍,因此时间复杂度为O(N);
空间复杂度:O(1)
原地修改的字符数组,没有占用和创建其他空间,只有两个常数级的指针。
swap可以有两种实现。
int tmp = s[i];
s[i] = s[j];
s[j] = tmp;
s[i] ^= s[j];
s[j] ^= s[i];
s[i] ^= s[j];
使用库函数的原则:
本着这样的原则,没有使用reverse库函数,而使用swap库函数。
在字符串相关的题目中,库函数对大家的诱惑力是非常大的,因为会有各种反转,切割取词之类的操作,这也是为什么字符串的库函数这么丰富的原因。
题目链接:反转字符串II
参考:https://programmercarl.com/0541.%E5%8F%8D%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2II.html
给定一个字符串 s 和一个整数 k,从字符串开头算起,每计数至 2k 个字符,就反转这 2k 字符中的前 k 个字符。
如果剩余字符少于 k 个,则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个,则反转前 k 个字符,其余字符保持原样。
示例1:
输入:s = "abcdefg", k = 2
输出:"bacdfeg"
示例2:
输入:s = "abcd", k = 2
输出:"bacd"
提示:
要摒弃传统的写for循环只能for(; ;i++)的思想,实际循环条件有很多种写法。
其实在遍历字符串的过程中,只要让 i += (2 * k),i 每次移动 2 * k 就可以了,然后判断是否需要有反转的区间。
因为要找的也就是每2 * k 区间的起点,这样写,程序会高效很多。
所以当需要固定规律一段一段去处理字符串的时候,要想想在在for循环的表达式上做做文章。
这里具体反转的逻辑我们要不要使用库函数呢,其实用不用都可以,使用reverse来实现反转也没毛病,毕竟不是解题关键部分。
注意reverse函数的调用写法。
使用reverse库函数的版本:
//时间复杂度:O(n)
//空间复杂度:O(1)
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;
}
};
也可以自己写一个左闭右开的reverse函数
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]);
}
}
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, i, i + k - 1);
continue;
}
// 3. 剩余字符少于 k 个,则将剩余字符全部反转。
reverse(s, i, s.size() - 1);
}
return s;
}
};
时间复杂度:O(N) 整个字符串长度为N,大约只有N/2的段需要处理,所以时间复杂度为O( N);
空间复杂度:O(1)
我们可以直接在原字符串上修改,空间复杂度为O(1)。
reverse(s, i, i + k - 1);
reverse(s, i, s.size() - 1);
比如说在第一种调用库函数的解法中
if (i + k <= s.size()) {
reverse(s.begin() + i, s.begin() + i + k );
}
当i=0,k=3,s.size=3时,这时还需要翻转,所以应该包含等号的情况。
题目链接:剑指Offer 05.替换空格
参考:https://programmercarl.com/%E5%89%91%E6%8C%87Offer05.%E6%9B%BF%E6%8D%A2%E7%A9%BA%E6%A0%BC.html
请实现一个函数,把字符串 s 中的每个空格替换成"%20"。
示例1:
输入:s = "We are happy."
输出:"We%20are%20happy."
限制:
用双指针法。
步骤:
疑问:为什么要从后向前填充,从前向后填充不行么?
从前向后填充就是O(n^2)的算法了,因为每次添加元素都要将添加元素之后的所有元素向后移动。
其实很多数组填充类的问题,都可以先预先给数组扩容带填充后的大小,然后在从后向前进行操作。
这么做有两个好处:
不用申请新数组。
从后向前填充元素,避免了从前向后填充元素时,每次添加元素都要将添加元素之后的所有元素向后移动的问题。
//时间复杂度:O(n)
//空间复杂度:O(1)
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;
}
};
时间复杂度:O(N)
首先统计string中空字符的数量,就有O(N)的复杂度,其次我们认为加长之后,仍然是O(N)级别的长度,然后left指针是会遍历一遍的,right指针也大体上跟着遍历了一遍,所以复杂度也为O(N),总体来说仍然是O(N)的时间复杂度。空间复杂度:O(N)
在C++中是O(1);如果字符串是可修改的,那么我们可以直接在原字符串上修改,空间复杂度为O(1)。
27.移除元素
15.三数之和
18.四数之和
206.翻转链表
142.环形链表II
344.反转字符串
那么vector< char > 和 string 又有什么区别呢?
其实在基本操作上没有区别,但是 string提供更多的字符串处理的相关接口,例如string 重载了+,而vector却没有。
所以想处理字符串,我们还是会定义一个string类型。
题目链接:翻转字符串里的单词
参考:https://programmercarl.com/0151.%E7%BF%BB%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2%E9%87%8C%E7%9A%84%E5%8D%95%E8%AF%8D.html
给你一个字符串 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"
解释:如果两个单词间有多余的空格,反转后的字符串需要将单词间的空格减少到仅有一个。
提示:
这道题目可以说是综合考察了字符串的多种操作。
这里我还是提高一下本题的难度:不要使用辅助空间,空间复杂度要求为O(1)。
解题思路如下:
举个例子,源字符串为:"the sky is blue "
首先,字符串的前后可能都有若干个多余的空格,所以需要先单独处理字符串前后的空格,用两个指针和两个while循环就OK。
比较棘手的是字符串中间的空格,在这里,我想到的是之前在数组里面做过的移除元素这道题,在那道题里面是移除特定的元素,在这里不是非常类似吗,只是这个元素变成了空格,因此,本题可以照搬那边的思路。
同样定义两个快慢指针,快指针用来遍历所有的元素,慢指针用来更新新的元素,这里要注意的是,单词之间需要保留有一个空格,这一点需要特殊处理。
这一步就和之前做过的题目都一样了,也是定义两个指针left和right,一个从头,一个从尾,交换元素。
通过一个while循环和start和end指针,找到一个个单词的区间,然后用第二步中定义的函数进行反转即可。
说明:
在移除多余空格时,不要用一层for循环遍历整个字符串,找到空格后用erase()函数去除空格,这样的时间复杂度是O(n^2)。
使用双指针法来去移除空格,最后resize(重新设置)一下字符串的大小,就可以做到O(n)的时间复杂度。
//时间复杂度:O(n)
//空间复杂度:O(1)
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);快慢指针总体来说都遍历了一遍,长度为N,因此时间复杂度为O(N),空间上只创建了四个指针,因此空间复杂度为O(1);
反转字符数组的函数,时间复杂度为O(N);空间复杂度为O(1);left和right两个指针从数组的两端向中间遍历,把数组遍历了一遍,数组长度为N,因此时间复杂度为O(N);空间上只有两个指针的内存,因此复杂度为O(1);
反转每个单词的函数,时间复杂度为O(N),空间复杂度为O(1);因为整体上每个单词中的每个字母都只会被操作一次,所以说时间复杂度为O(N);空间上只定义了常数个指针,空间复杂度为O(1)
时间复杂度:O(N)总体的时间复杂度是调用的这些子函数的时间复杂度的和,因此仍然是O(N)
空间复杂度:O(1)
题目链接:剑指Offer58-II.左旋转字符串
参考:https://programmercarl.com/%E5%89%91%E6%8C%87Offer58-II.%E5%B7%A6%E6%97%8B%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2.html
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如,输入字符串"abcdefg"和数字2,该函数将返回左旋转两位得到的结果"cdefgab"。
示例1:
输入: s = "abcdefg", k = 2
输出: "cdefgab"
示例2:
输入: s = "lrloseumgh", k = 6
输出: "umghlrlose"
限制:
可以通过局部反转+整体反转 达到左旋转的目的。
具体步骤为:
最后就可以达到左旋n的目的,而不用定义新的字符串,完全在本串上操作。
//时间复杂度:O(n)
//空间复杂度:O(1)
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;
}
};
我们已经反转好多次字符串了,来一起回顾一下吧。
在这篇文章344.反转字符串 ,第一次讲到反转一个字符串应该怎么做,使用了双指针法。
然后发现541. 反转字符串II ,这里开始给反转加上了一些条件,当需要固定规律一段一段去处理字符串的时候,要想想在for循环的表达式上做做文章。
后来在151.翻转字符串里的单词 中,要对一句话里的单词顺序进行反转,发现先整体反转再局部反转 是一个很妙的思路。
最后再讲到本题,本题则是先局部反转再 整体反转,与151.翻转字符串里的单词 类似,但是也是一种新的思路。