目录
151.翻转字符串里的单词
题目链接：151. 反转字符串中的单词 - 力扣（LeetCode）
给你一个字符串 s ，请你反转字符串中 单词 的顺序。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
解题思路：
我的想法：采用双指针，找到每一个单词。指针i ：单词的结尾，指针j：单词的开头。利用substr取出单词，添加到结果中。
class Solution {
public:
string reverseWords(string s) {
string result = "";
for(int i = s.size() - 1; i >= 0; i--){
// i:单词的结尾
while(i >= 0 && s[i] == ' '){
i--;
}
//j：单词的开头
int j = i;
while(j >= 0 && s[j] != ' '){
j--;
}
// 取出单词，substr(开始位置，取几个)
if(i >= 0)
result += s.substr(j + 1,i - j) + ' ';
//i 移动到单词末尾
i = j;
}
// 不取最后一个空格
return result.substr(0,result.size()-1);
}
};也可以不使用辅助空间。去除多余空格，整体反转+局部反转
整体反转实现单词的大致位置是正确的，再通过局部反转使得单词顺序正确
问题1：如何去除多余空格？
for循环从前向后遍历，遇到空格了就erase。一个erase就是O(n)的操作。
erase操作上面还套了一个for循环，那么移除冗余空格的代码时间复杂度为O(n^2)。
那么使用双指针法来去移除空格，最后resize（重新设置）一下字符串的大小，就可以做到O(n)的时间复杂度。快指针寻找单词，慢指针指向更新的位置。
问题2：如何确保单词之间的空格？
方法1：找到一个单词后，在单词后加空格。最后一个单词不加空格
方法2：找到单词前，先加空格，再加单词。在第一个单词的时候不加
从前向后遍历，判断是否是最后一个单词，无法判断。判断是否是第一个单词，容易。所以，这里我们采用第二种方法。对于方法1，也不是不可以，我们需要另外写一段逻辑，来去除结尾多余空格。
class Solution {
public:
void removeExtraSpaces(string& s){
int slow = 0;//slow：单词更新的位置
for(int i = 0; i < s.size(); i++){
// i:寻找单词
if(s[i] != ' '){//找到单词的开头
//先 添加空格
if(slow > 0){
//不是第一个单词
s[slow++] = ' ';
}
//再 添加单词
while(i < s.size() && s[i] != ' '){
s[slow++] = s[i++];
}
}
}
s.resize(slow);
}
string reverseWords(string s) {
// 1.移除字符串中多余的空格
removeExtraSpaces(s);
// 2.反转整个字符串
reverse(s.begin(),s.end());
//3.反转每个单词
for(int i = 0; i < s.size(); i++){
int start = i;
while(i < s.size() && s[i] != ' '){
i++;
}
reverse(s.begin() + start,s.begin()+i);
}
return s;
}
};55. 右旋字符串
题目链接：55. 右旋字符串（第八期模拟笔试） (kamacoder.com)
字符串的右旋转操作是把字符串尾部的若干个字符转移到字符串的前面。给定一个字符串 s 和一个正整数 k，请编写一个函数，将字符串中的后面 k 个字符移到字符串的前面，实现字符串的右旋转操作。
例如，对于输入字符串 "abcdefg" 和整数 2，函数应该将其转换为 "fgabcde"。
解题思路：整体反转+局部反转
#include<iostream>
#include<algorithm>
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); // 先反转前一段，长度n
reverse(s.begin() + n, s.end()); // 再反转后一段
cout << s << endl;
} 左反转，思路是一样一样的，就是反转的区间不同而已。
KMP算法
KMP算法的核心在于，当发现字符串不匹配时，利用之前已经匹配成功的字符信息，将模式串滑动到某个有效的起始位置，而不是像朴素匹配算法那样，每次不匹配都将模式串回退到起始位置。这样做可以显著提高匹配效率。
KMP算法的时间复杂度为O(m+n)，其中m和n分别是主串和模式串的长度。这是因为每个字符在主串和模式串中最多被比较一次，且next数组的计算也是线性的。
前缀表
前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。
首先要知道前缀表的任务是当前位置匹配失败，找到之前已经匹配上的位置，再重新匹配，此也意味着在某个字符失配时，前缀表会告诉你下一步匹配中，模式串应该跳到哪个位置。
那么什么是前缀表：记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。
如何利用 前缀表找到 当字符不匹配的时候应该指针应该移动的位置。如动画所示：
不匹配的时候，查看当前 前缀表的前一个，进行回退
如何计算前缀表
- 前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串。
- 后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。
手动计算前缀表
前缀表[0] : 表示 "a" 的最长公共前后缀的长度是0
前缀表[1] : 表示 "aa"的最长公共前后缀的长度是1
前缀表[2] : 表示 "aab"的最长公共前后缀的长度是0
…………
代码实现
next数组就是前缀表。构造next数组其实就是计算模式串s，前缀表的过程。
主要有如下三步：
- 初始化
- 处理前后缀不相同的情况
- 处理前后缀相同的情况
初始化：
定义两个指针i和j，j指向前缀末尾位置，i指向后缀末尾位置。
j 其实也表示了最长公共前后缀的长度。
next[0] = 0。因为1个字符，既没有前缀，也没有后缀，所以最长公共前后缀长度为0.
处理两种情况：
计算next数组，代码如下：
void getNext(int* next, const string& s){
int j = 0;
next[0] = 0;
for(int i = 1; i < s.size(); i++) { // 注意i从1开始
while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
j = next[j]; // 向前回退
}
if (s[i] == s[j + 1]) { // 找到相同的前后缀
j++;
}
next[i] = j; // 将j（前缀的长度）赋给next[i]
}
}很多实现都是把前缀表统一减一（右移一位，初始位置为-1）之后作为next数组。
其实这并不涉及到KMP的原理，而是具体实现，next数组既可以就是前缀表，也可以是前缀表统一减一（右移一位，初始位置为-1）。
KMP可以解决两类经典问题：
- 匹配问题：28. 实现strStr()
- 重复子串问题：459. 重复的子字符串
28. 实现 strStr()
题目链接：28. 找出字符串中第一个匹配项的下标 - 力扣（LeetCode）
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。
完整代码
class Solution {
public:
void getNext(int* next, const string& s) {
int j = 0;
next[0] = 0;
for(int i = 1; i < s.size(); i++) {
while (j > 0 && s[i] != s[j]) {
j = next[j - 1];
}
if (s[i] == s[j]) {
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 = 0;
for (int i = 0; i < haystack.size(); i++) {
while(j > 0 && haystack[i] != needle[j]) {
j = next[j - 1];
}
if (haystack[i] == needle[j]) {
j++;
}
if (j == needle.size() ) {
return (i - needle.size() + 1);
}
}
return -1;
}
};459.重复的子字符串
题目链接：459. 重复的子字符串 - 力扣（LeetCode）
给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。
KMP
在由重复子串组成的字符串中，最长相等前后缀不包含的子串就是最小重复子串
class Solution {
public:
bool repeatedSubstringPattern(string s) {
vector<int> next(s.size());
int len = s.size();
// 求s的最长公共前后缀
//1.初始化
int j = 0;
next[0] = 0;
for(int i = 1; i < len; i++){
//情况1： s[i] != s[j],j 回退
while(j > 0 && s[i] != s[j]){
j = next[j - 1];
}
//情况2：s[i] == s[j]
if(s[i] == s[j]){
j++;
}
next[i] = j;
}
int sub = len - next[len - 1];
return sub != len && len % sub == 0;
}
};移动匹配
判断字符串s是否由重复子串组成，只要两个s拼接在一起，里面还出现一个s的话，就说明是由重复子串组成。
当然，我们在判断 s + s 拼接的字符串里是否出现一个s的的时候，要刨除 s + s 的首字符和尾字符，这样避免在s+s中搜索出原来的s，我们要搜索的是中间拼接出来的s。
class Solution {
public:
bool repeatedSubstringPattern(string s) {
string t = s + s;
t.erase(t.begin()); t.erase(t.end() - 1); // 掐头去尾
if (t.find(s) != std::string::npos) return true; // r
return false;
}
};
扫一扫
1094
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
