目录
LeetCode344.反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组
s的形式给出。不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
思路：这道题还是很简单的，使用双指针法进行一次遍历即可。
下面给出了两种方式，第一种是使用while循环，两端交换逼近即可
第二种是for循环，也是两端交换逼近。
不过就代码量来说，第二种方法更简洁好看。
另外有的人说，直接使用库函数中的reverse函数即可，一句代码就能搞定。
虽然也能过，但是本题主要考察的就是倒置，如果一味地追求使用库函数，不理解一些基础实现原理是很吃亏的。
当本题考察核心不是相关重要实现机制时，一般来说就可以用，比如本题就可以使用swap函数，因为本身也没有考察交换函数怎么写，况且交换的原理机制大家都很熟（三段式）。
1、while循环
void reverseString(vector<char>& s) {
int left = 0, right = s.size() - 1; //设置双指针
int tmp; //设置中间元素
while(right > left){
tmp = s[right];
s[right] = s[left];
s[left] = tmp;
//两两交换元素，从两端逼近，
//也可以直接使用swap(s[right],s[left]),简化代码
right --;
left ++; //双指针移动位置
}
}2、for循环
void reverseString(vector<char>& s) {
for(int i = 0, j = s.size() - 1; i < j; i ++, j --){
swap(s[i], s[j]);
}
}时间复杂度：O(n)
空间复杂度：O(1)
LeetCode541.反转字符串II
给定一个字符串
s和一个整数k，从字符串开头算起，每计数至2k个字符，就反转这2k字符中的前k个字符。
- 如果剩余字符少于
k个，则将剩余字符全部反转。- 如果剩余字符小于
2k但大于或等于k个，则反转前k个字符，其余字符保持原样。V
思路： 本题编写了两个函数，一个倒置字符串的函数，一个按照题意花式倒转的函数。
倒置函数上面已经提及了，这里不再说明。关键是花式倒转的题目，我这里提供了两种思路，一种是使用计数变量，然后通过while循环以及逻辑判断来进行相关区间元素的倒置；第二种是在for循环里面，通过下标i的变化来实现题目中所描述的条件倒置。
值得注意的是，下标的一些细节问题，否则可能没有办法通过。
1、统计加while循环
void reverseString(string& s, int begin, int end){
int left = begin, right = end;
while(right > left){
swap(s[left], s[right]);
left ++;
right --;
}
}
string reverseStr(string s, int k) {
int index = 0; //用于计数和标记下标
if(s.size() < k){
reverseString(s, 0, s.size() - 1);
return s;
}else if(s.size() < 2 * k){
reverseString(s, 0, k - 1);
return s;
}
while(index < s.size()){
reverseString(s, index, index + k - 1);
index += 2 * k;
if(s.size() - index < k){
reverseString(s, index, s.size() - 1);
break;
}else if(s.size() - index < 2 * k){
reverseString(s, index, index + k - 1);
break;
}
}
return s;
}2、for循环控制下标变化
void reverseString(string& s, int begin, int end){
int left = begin, right = end;
while(right > left){
swap(s[left], s[right]);
left ++;
right --;
}
}
string reverseStr(string s, int k) {
for(int i = 0; i < s.size(); i += 2 * k){
if(i + k <= s.size()){ //也就是说字符串足够长，所以能够对前k个元素进行操作
reverseString(s, i, i + k - 1);
}else{
reverseString(s, i, s.size() - 1); //剩余字符串不够k个元素了
}
}
return s;
}时间复杂度：O(n)
空间复杂度：O(1)
54.替换数字
题目描述
给定一个字符串 s，它包含小写字母和数字字符，请编写一个函数，将字符串中的字母字符保持不变，而将每个数字字符替换为number。 例如，对于输入字符串 "a1b2c3"，函数应该将其转换为 "anumberbnumbercnumber"。
输入描述
输入一个字符串 s,s 仅包含小写字母和数字字符。
输出描述
打印一个新的字符串，其中每个数字字符都被替换为了number
输入示例
a1b2c3
输出示例
anumberbnumbercnumber
提示信息
数据范围：
1 <= s.length < 10000。
思路：这道题有两个思路。第一个使用辅助数组法，第二个不使用辅助数组，直接在原字符串上使用指针法操作。
1、辅助数组法
对于第一种使用辅助数组，首先依次遍历字符串的内容，当字符串元素不是数字是添加入辅助字符串；当是数字时，将number添加入辅助字符串，最后遍历完返回辅助字符串即可。代码如下。
#include<iostream>
#include<string>
using namespace std;
int main(){
string s, result;
while(cin>>s){
for(int i = 0; i < s.size(); i ++){
if(s[i] >= '0' && s[i] <= '9'){
result += "number"; //当遇到数字时，将number添加到result字符串中
}else{
result += s[i];
}
}
cout << result << endl;
}
}时间复杂度：O(n)
空间复杂度：O(n)
2、指针法
首先统计字符串中的数字出现次数，将一个指针指向原字符串的原末尾，对原字符串扩容至能够容下所有数字转化为number的大小，设置一个指针指向新的末尾，从末尾开始，将原字符串元素移动到新的位置，通过两个指针配合进行，直至循环完成。代码如下。
#include<iostream>
#include<string>
using namespace std;
int main(){
string s;
while(cin >> s){
//首先统计接收到的字符串中数字的个数
int index_old = s.size() - 1; //指向原字符串末尾的指针
int count = 0;
for(int i = 0; i < s.size(); i ++){
if(s[i] >= '0' && s[i] <= '9'){
count ++;
}
}
//对字符串s扩容
s.resize(s.size() + 5 * count);
//虽然number字符数为6，但是所替换的数字时占了一个位置的，
//因此每个数字只需要扩充5个数字
int index_new = s.size() - 1;
while(index_old >= 0){
if(s[index_old] >= '0' && s[index_old] <= '9'){
s[index_new --] = 'r';
s[index_new --] = 'e';
s[index_new --] = 'b';
s[index_new --] = 'm';
s[index_new --] = 'u';
s[index_new --] = 'n';//替换数字为number
}else{
s[index_new --] = s[index_old];
}
index_old --;
}
cout << s << endl;
}
}时间复杂度：O(n)
空间复杂度：O(1)
这里有人会问为什么不从前往后移动元素，而要从后往前移动？
那是因为如果从前往后移动，那么当某个数字需要变化为number时，需要将其后面的元素都移动到后面相应位置，这会导致O(n^2)的时间复杂度，是不可取的。
从上面可以看出采用辅助数组和指针法的区别，虽然指针法代码量稍多，但是保证了O(1)的空间复杂度。
当然，平常的话视情况选择即可，如果空间复杂度没有严苛要求，还是可以使用辅助数组法的。
LeetCode151.反转字符串中的单词
给你一个字符串
s，请你反转字符串中 单词 的顺序。单词 是由非空格字符组成的字符串。
s中使用至少一个空格将字符串中的 单词 分隔开。返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
注意：输入字符串
s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
思路：这道题的难点在于如何去除多余空格。
一般思路有两种，一种是辅助数组法，还有一种是使用指针法。
1、辅助数组法
采用辅助字符串来保存单词，进入循环后，遍历字符串，当遇到空格的时候continue，遇到单词是则添加进入辅助字符串，当满足一定条件时，将统计到的单词放入字符串数组中，并将辅助字符串置空，继续统计，最后统计完成，将辅助字符串中的单词倒序放入字符串中，返回即可。代码如下。
string reverseWords(string s) {
vector<string> str; //用于存放一会去除空格后的各元素
string tmp = ""; //辅助字符串
for(int i = 0; i < s.size(); i ++){
if(tmp != "" && s[i] == ' '){
//当tmp不为空，并且所访问的元素变为空格时，
//说明一个单词已经存入了tmp,开始将其导出
str.push_back(tmp);
tmp = ""; //将辅助字符串置空
}
if(s[i] == ' ') continue;//如果遇到空格，直接continue
tmp += s[i];
if(tmp != "" && i == s.size() - 1){
//当tmp不为空并且i为s中最后一个索引，
//说明该字符串末尾没有空格，需要将tmp中的单词导出
str.push_back(tmp);
}
}
string result; //最后的输出结果
for(int i = str.size() - 1; i >= 0; i --){
result += str[i];
if(i != 0){
result += ' '; //为每个单词间添加空格，当为最后一个单词时不用再添加空格
}
}
return result;
}时间复杂度：O(n)
空间复杂度：O(n)
2、指针法
这里采用指针法是为了去除多余的空格，这也是本题的关键所在。
使用slow、fast指针，依次从前往后遍历，将字符串前面的空格去除，再去除中间的多余空格，最后对末尾的空格去除，其实这时候的去除是对slow所处位置的一个判断，并且缩小s的大小，保证其是不含多余空格的字符串。关于去除空格的一般思路代码如下所示。
//去除多余空格符号
void clearExtralSpace(string& s){
int slow = 0, fast = 0;
//去除字符串前面的空格
while(fast < s.size() && s[fast] == ' '){
fast ++;
}
//去除中间的多余空格
for(; fast < s.size(); fast ++){
if(fast - 1 > 0 && s[fast] == s[fast - 1] && s[fast] == ' '){
continue;
}else{
s[slow ++] =s[fast];
}
}
//去除字符串结尾的多余空格
if(slow - 1 > 0 && s[slow - 1] == ' '){
s.resize(slow - 1); //重新设置字符串大小
}else{
s.resize(slow);
}
}当然，还可以进一步优化一下，使用一个指针，直接进入循环开始去除空格，最后根据slow的位置缩小原字符串的大小，即可得到不含多余空格的字符串。代码如下所示。
//去除多余空格符号
void clearExtralSpace(string& s){
int slow = 0; //设置标志指针
for(int i = 0; i < s.size(); i ++){
if(s[i] != ' '){
if(slow > 0) s[slow ++] = ' ';
//当slow大于0的时候说明其不是第一个单词了，需要手动添加空格
while(i < s.size() && s[i] != ' '){
//这里在此判断i<s.size()是因为可能在while循环里面自加从而越限
s[slow ++] = s[i ++];
}
}
}
s.resize(slow);
}当把字符串中的多余空格去除后，这道题就变得简单了，具体思路就是先对去除空格后的字符串进行倒置，这是虽然每个单词所在位置大框架有了，但是每个单词顺序还是倒置的，所以这时候开始进行遍历，对每一个单词再进行倒置，当成功将倒置的字符串中的所有单词再次倒置后，即可得到答案。整体代码如下所示。
//反转字符串(反转区间是左闭右闭的)
void reverseString(string& s, int begin, int end){
for(int i = begin, j = end; i < j; i ++, j --){
swap(s[i], s[j]);
}
}
//去除多余空格符号
void clearExtralSpace(string& s){
int slow = 0; //设置标志指针
for(int i = 0; i < s.size(); i ++){
if(s[i] != ' '){
if(slow > 0) s[slow ++] = ' ';
//当slow大于0的时候说明其不是第一个单词了，需要手动添加空格
while(i < s.size() && s[i] != ' '){
//这里在此判断i<s.size()是因为可能在while循环里面自加从而越限
s[slow ++] = s[i ++];
}
}
}
s.resize(slow);
}
string reverseWords(string s) {
clearExtralSpace(s); //去除多余空格号
reverseString(s, 0, s.size() - 1);
int start = 0; //首指针
for(int i = 0; i <= s.size(); i ++){
//这里i<=s.size()是因为为了统一反转的格式，可以自行体会一下
if(s[i] == ' ' || i == s.size()){
reverseString(s, start, i - 1);
//当遇到空格时，将该范围内字符串反转
start = i + 1; //重新给首指针赋值
}
}
return s;
}时间复杂度：O(n)
空间复杂度：O(1)
55.右旋字符串
题目描述
字符串的右旋转操作是把字符串尾部的若干个字符转移到字符串的前面。给定一个字符串 s 和一个正整数 k，请编写一个函数，将字符串中的后面 k 个字符移到字符串的前面，实现字符串的右旋转操作。
例如，对于输入字符串 "abcdefg" 和整数 2，函数应该将其转换为 "fgabcde"。
输入描述
输入共包含两行，第一行为一个正整数 k，代表右旋转的位数。第二行为字符串 s，代表需要旋转的字符串。
输出描述
输出共一行，为进行了右旋转操作后的字符串。
输入示例
2 abcdefg
输出示例
fgabcde
提示信息
数据范围：
1 <= k < 10000,
1 <= s.length < 10000;
思路：本题思路仍然有两个，一个是辅助数组法，另一个是多次反转法。
1、辅助数组法
设置一个辅助字符串，将源字符串的后面k个元素导出并放入其中（注意顺序），然后再循环遍历将源字符串中的前面s.size()-k个元素依次放入辅助字符串，最后输出即可。
#include<iostream>
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
string s, result;
int k;
cin >> k >> s;
for(int i = s.size() - k; i < s.size(); i ++){
result += s[i];//将字符串中的倒数第k个及以后的值放入辅助数组
}
for(int i = 0; i < s.size() - k; i ++){
result += s[i]; //将剩余的字符串里面的前面的值导入
}
cout << result << endl; //返回操作完成的字符串
}时间复杂度：O(n)
空间复杂度：O(n)
2、多次反转法
我们要求的是右旋的字符串，所以可以先将字符串所有元素倒置，然后根据k的值，分块再进行一次倒置，即可得到最终结果。
当然，如果先选择分块倒置，再总体倒置，思路也是可以的，只不过得注意一下块的区域，以免出错。
右旋可以这样做，那么左旋也是同样的思路，也能做出来。
1、先整体后分块
#include<iostream>
#include<string>
using namespace std;
//字符串倒置函数
void reverseString(string& s, int begin, int end){
for(int i = begin, j = end; i < j; i ++ , j --){
swap(s[i], s[j]);
}
}
int main(){
int k;
string s;
cin >> k >> s;
reverseString(s, 0, s.size() - 1);//将字符串倒置
reverseString(s, 0, k - 1); //将前k个元素倒置
reverseString(s, k, s.size() - 1);//将后面元素倒置
cout << s << endl;
}2、先分块后整体
#include<iostream>
#include<string>
using namespace std;
//字符串倒置函数
void reverseString(string& s, int begin, int end){
for(int i = begin, j = end; i < j; i ++ , j --){
swap(s[i], s[j]);
}
}
int main(){
int k;
string s;
cin >> k >> s;
reverseString(s, 0, s.size() - k - 1); //将前s.size()-k个元素倒置
reverseString(s, s.size() - k, s.size() - 1);//将后面k个元素倒置
reverseString(s, 0, s.size() - 1);//将整个字符串倒置
cout << s << endl;
}时间复杂度：O(n)
空间复杂度：O(1)
其实我们可以看到，如果对于字符串的题目，使用辅助数组法的话代码量会少不少，但是会增加额外的空间开销，而如果再原数组上操作，则不会增加。
实际中可以根据需要，如果能接受额外开销，那么使用辅助数组法确实简单不少，至少代码量相对较少。
感谢你的阅读，希望我的文章能够给你帮助，如果有帮助，麻烦点赞加收藏，或者点点关注，非常感谢。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
