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
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类型