反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。
示例 1：
输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]
示例 2：
输入：["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]
这才是是标准的入门难度题，reverse库函数可以直接解决，但是在这道题，建议体现一下双指针的用法，毕竟没有人会想只考你库函数会不会调用。
时间复杂度: O(n) 空间复杂度: O(1)
#include<iostream>
#include<vector>
using namespace std;
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]);
}
}
};反转字符串Ⅱ
给定一个字符串 s 和一个整数 k，从字符串开头算起, 每计数至 2k 个字符，就反转这 2k 个字符中的前 k 个字符。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
示例:
输入: s = "abcdefg", k = 2
输出: "bacdfeg"
这道题主要就考虑两个点，一个是i到i字符串末尾<k的情况，一个是i到i+2k的范围，通过后面这个大范围，反转前K个，否则全部反转，这是唯二条件，没有别的，别多想。
时间复杂度: O(n) 空间复杂度: O(1)
class Solution {
public:
void reverse(string& s, int start, int end) {
for (int i = 0, j = s.size() - 1; i < s.size() / 2; i++, j--) {
swap(s[i], s[j]);
}
}
string reverse(string s, int k) {
for (int i = 0; i < s.size() - 1; i += (2 * k)) {
if (i + k <= s.size()) {
reverse(s, i, i + k - 1);
continue;
}
reverse(s, i, s.size() - 1);
}
return s;
}
};替换数字
给定一个字符串 s，它包含小写字母和数字字符，请编写一个函数，将字符串中的字母字符保持不变，而将每个数字字符替换为number。
例如，对于输入字符串 "a1b2c3"，函数应该将其转换为 "anumberbnumbercnumber"。
对于输入字符串 "a5b"，函数应该将其转换为 "anumberb"
输入：一个字符串 s,s 仅包含小写字母和数字字符。
输出：打印一个新的字符串，其中每个数字字符都被替换为了number
样例输入：a1b2c3
样例输出：anumberbnumbercnumber
数据范围：1 <= s.length < 10000。
这道题主要要知道，数组的填充，很多的解决办法都是从后向前进行填充，替换了number数字，那只需要先在原来内存里拓展大小到新的大小，再用双指针，把原来数组赋值给新的数组，再一步步向前移动。避免了从前往后还需要整体后移的麻烦。
时间复杂度: O(2n) 空间复杂度: O(1)
int main() {
string s;
while (cin >> s) {
int sOldIndex = s.size() - 1;
int count = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] >= '0' && s[i] <= '9') {
count++;
}
}
s.resize(s.size() + count * 5);
int sNewIndex = s.size() - 1;
while (sOldIndex >= 0) {
if (s[sOldIndex] >= '0' && s[sOldIndex] < '9') {
s[sNewIndex--] = 'r';
s[sNewIndex--] = 'e';
s[sNewIndex--] = 'b';
s[sNewIndex--] = 'm';
s[sNewIndex--] = 'u';
s[sNewIndex--] = 'n';
}
else {
s[sNewIndex--] = s[sOldIndex];
}
sOldIndex--;
}
cout << s << endl;
}
}反转字符串里的单词
给定一个字符串，逐个翻转字符串中的每个单词。
示例 1：
输入: "the sky is blue"
输出: "blue is sky the"
示例 2：
输入: " hello world! "
输出: "world! hello"
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
示例 3：
输入: "a good example"
输出: "example good a"
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个
这道题很大的难点在于空格的处理，如果用简单的思路进行单纯的去空格又比较耗时，时间复杂度会上来，毕竟一个erase就是O（n）的操作，所以也可以通过双指针的灵活运用进行去空格的操作，这一段比较难理解，看了好几遍这个高级版的思路也没怎么理清楚，等下次复习时候再好好想想吧QAQ
- 时间复杂度: O(n)
- 空间复杂度: O(1) 或 O(n)，取决于语言中字符串是否可变
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;
}
};右旋转字符串
字符串的右旋转操作是把字符串尾部的若干个字符转移到字符串的前面。给定一个字符串 s 和一个正整数 k，请编写一个函数，将字符串中的后面 k 个字符移到字符串的前面，实现字符串的右旋转操作。
例如，对于输入字符串 "abcdefg" 和整数 2，函数应该将其转换为 "fgabcde"。
输入：输入共包含两行，第一行为一个正整数 k，代表右旋转的位数。第二行为字符串 s，代表需要旋转的字符串。
输出：输出共一行，为进行了右旋转操作后的字符串。
很巧妙，这道题可以直接把整个反过来，然后在中间截断的位置进行两次反向即可
主要注意思考一下左旋和右旋的区别，这个N不同得到的结果是不同的，还有先整体转还是先局部转，结果也是不同的，有些是len-n，总之遇到了画个图，仔细想想范围，不难。但一定要仔细！
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
int main(){
int n;
string s;
cin >> n;
cin >> s;
int len = s.size();
reverse(s.begin(), s.end());
reverse(s.begin(), s.begin() + n);
reverse(s.begin() + n, s.end());
cout << s << endl;
system("pause");
return 0;
}实现strStr()
实现 strStr() 函数。
给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
示例 1: 输入: haystack = "hello", needle = "ll" 输出: 2
示例 2: 输入: haystack = "aaaaa", needle = "bba" 输出: -1
说明: 当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。 对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。
KMP！字符串匹配大法！
当出现字符串不匹配时，可以记录一部分之前已经匹配的文本内容，利用这些信息避免从头再去做匹配。KMP（Knuth,Morris,Pratt,发明的方法）
KMP的精髓，就是next数组。next数组里的数字表示的是什么，为什么这么表示？
next数组就是一个前缀表（prefix table），前缀表是用来回退的，它记录了模式串与主串（文本串）不匹配的时候，模式串应该从哪里开始重新匹配。
前缀表：记录下标 i 之前（包括i）的字符串中，有多大长度的相同前缀后缀。
字符串的前缀：不包含最后一个字符的所有以第一个字符开头的连续子串。
后缀是：不包含第一个字符的，所有以最后一个字符结尾的连续子串。
KMP要找的，跳转的位置，就是最长公共（相等）前后缀
怎么计算前缀表：子串的序号下表，对应从头开始的每一个小子串的前缀表，
模式串和前缀表对应位置的数字表示：下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀
找到不匹配的位置时候，要看它前一个字符的前缀表的数值是多少。
nex数组就可以是前缀表，很多实现都是把前缀表统一-1（右移一位，初始位置-1）
KMP O（m+n）极大提高了字符串匹配中的搜索效率
next数组构造方式
1.定义两个指针，i 和 j, j 指向前缀末尾位置（第一个数，不包含最后一个数字）， i 指向后缀末尾位置（不包含第一个数字）
2.前后缀不相同时，next【j】记录着 j 之前的子串的相同前后缀的长度（位置），所以令j = next[j]进行向前回退
3.前后缀相同时，同时向后移动 i和 j 说明找到了相同的前后缀，同时还要将j赋值给next【i】，继续记录长度
void getNext(int* next. const string& s){
int j = -1;
next[0] = j;
for(int i = 1;i<s.size();i++){
while(j>=0 && s[i] != s[j+1]){
j = next[j];
}
if(s[i]=s[j+1]{
j++;
}
next[i] = j;
}
}这道题的详细代码
class Solution {
public:
void getnext(int* next, const string& s) {
int j = -1;
next[0] = j;
for (int i = 1; i < s.size(); i++) {
while (j >= 0 && s[i] != s[j + 1]) {
j = next[j];
}
if (s[i] == s[j + 1]){
j++;
}
next[i] = j;
}
}
int strStr(string haystack, string needle) {
if (needle.size() == 0) {
return 0;
}
vector<int> next(needle.size());
getnext(&next[0], needle);
int j = -1;
for (int i = 0; i < haystack.size(); i++) {
while (j >= 0 && haystack[i] != needle[j + 1]) {
j = next[j];
}
if (haystack[i] == needle[j + 1]) {
j++;
}
if (j == (needle.size() - 1)) {
return (i - needle.size() + 1);
}
}
return -1;
}
};重复的字符串
给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。
示例 1:
- 输入: "abab"
- 输出: True
- 解释: 可由子字符串 "ab" 重复两次构成。
示例 2:
- 输入: "aba"
- 输出: False
这道题可以通过移动匹配的方法，先复制一份s,然后再进行移动匹配，看能不能找到一份和之前一样的子串，如果有说明是重复的 abab 变成 abababab 再掐头去尾 bababa,中间有abab ,所以重复
class Solution {
public:
bool repeatSubstringPattern(string s) {
string t = s + s;
t.erase(t.begin());
t.erase(t.end() - 1);
if (t.find(s) != std::string::npos)return true;
return false;
}
};小总结
vector< char > & string
其实在基本操作上没有区别，但是 string提供更多的字符串处理的相关接口，例如string 重载了+，而vector却没有。所以想处理字符串，最好还是定义一个string类型。
不要过于习惯于调用substr，split，reverse之类的库函数，却不知道其实现原理，也不知道其时间复杂度，这样实现出来的代码，如果在面试现场，面试官问：“分析其时间复杂度”的问题，就蒙了
字符串类类型的题目，往往想法比较简单，但是实现起来并不容易，复杂的字符串题目非常考验对代码的掌控能力。双指针法是字符串处理的常客。
