本系列总计六篇文章,是 基于STL实现的笔试题常考七大基本数据结构 该文章在《代码随想录》和《labuladong的算法笔记》题目中的具体实践,每篇的布局是这样的:开头是该数据结构的总结,然后是在不同场景的应用,以及不同的算法技巧。本文是系列第四篇,介绍了字符串的相关题目,重点是要掌握快慢、左右双指针算法,滑动窗口算法(与哈希表结合),KMP算法。
下面文章是在《代码随想录》和《labuladong的算法笔记》题目中的具体实践:
【笔记】数组
【笔记】链表
【笔记】哈希表
【笔记】字符串
【笔记】栈与队列
【笔记】二叉树
0、总结
- 双指针(头尾、快慢、滑动窗口、KMP)
- 涉及反转的,巧用库函数和迭代器,亦可自己定义reverse
- string是字符串版本的vector,重载了+以拼接字符
- KMP算法
1、普通双指针
344. 反转字符串 - 力扣(LeetCode)
两个思路:
-
库函数+迭代器
-
双指针,自写reverse+swap
class Solution {
public:
void reverseString(vector<char>& s) {
if (s.size() == 0) return;
for (int i = 0, j = s.size() - 1; i < j; i++, j--) {
swap(s[i], s[j]);
}
return;
}
};
541. 反转字符串 II - 力扣(LeetCode)
【思路很巧妙】
思路:
每次遍历时只要让 i += (2 * k) 就可以了,然后判断是否需要有反转的区间,这样子每次i更新完都是需要翻转的区间起点
class Solution {
public:
string reverseStr(string s, int k) {
if (s.size() == 0) return "";
// 遍历时只要让 i += (2 * k) 就可以了,然后判断是否需要有反转的区间,每次都是区间起点
for (int i = 0; i < s.size(); i += 2 * k) {
// 剩余字符小于2k个,但大于等于k个,反转前k个
if (i + k < s.size()) {
reverse(s.begin() + i, s.begin() + i + k);
}
// 剩余字符少于k个,全部反转
else if (i + k >= s.size()) {
reverse(s.begin() + i, s.end());
}
}
return s;
}
};
剑指 Offer 05. 替换空格 - 力扣(LeetCode)
思路:
先遍历一遍,记录空格数并且扩容,然后 双指针 从后向前,原地填充
若从前向后原地填充,每次更新元素都要将后面所有元素后移,时间复杂度O(n2)
若开辟新空间用于填充,则有额外O(n)空间开销
class Solution {
public:
string replaceSpace(string s) {
if (s.size() == 0) return "";
int oldSize = s.size();
// 先扩容
int num = 0;
for (char c : s) {
if (c == ' ') num++;
}
s.resize(oldSize + num * 2);
// 双指针原地从后向前填充
for (int i = oldSize - 1, j = s.size() - 1; i >= 0; i--, j--) {
if (s[i] != ' ') {
s[j] = s[i];
}
else {
s[j] = '0';
s[j - 1] = '2';
s[j - 2] = '%';
j -= 2;
}
}
return s;
}
};
151. 反转字符串中的单词 - 力扣(LeetCode)
【相当的好题】
思路:
三步走,先用 双指针 去除开头、中间、结尾处多余的括号,这一步是难点
然后,翻转整个字符串
最后,再反转每个单词
class Solution {
public:
string reverseWords(string s) {
removeBlankspace(s);
reverse(s, 0, s.size() - 1);
int start = 0;
for (int i = 0; i <= s.size(); i++) {
// 每逢单词结束或字符串结束,才反转
if (i == s.size() || s[i] == ' ') {
reverse(s, start, i - 1);
start = i + 1;
}
}
return s;
}
void reverse(string& s, int start, int end){ //翻转,区间写法:左闭又闭
for (int i = start, j = end; i < j; i++, j--) {
swap(s[i], s[j]);
}
}
// 双指针去除多余前、后空格,保证每个单词中间只有一个空格
void removeBlankspace(string& s) {
// 确定初始位置
int slow = 0;
for (int i = 0; i < s.size(); ++i) {
// s[i]不为空时才处理,这就保证了去除多余前、后空格
if (s[i] != ' ') {
// slow已经记录至少一个单词,在记录下一个单词时,需要补充空格
// 这就保证每个单词中间只有一个空格
if (slow != 0) s[slow++] = ' ';
// 将非空的字符串覆盖到前面来
while (i < s.size() && s[i] != ' ') {
s[slow++] = s[i++];
}
}
}
// 返回实际长度
s.resize(slow);
}
};
剑指 Offer 58 - II. 左旋转字符串 - 力扣(LeetCode)
思路:
两次局部反转 + 一次全局翻转,reverse中传递引用,因为要修改s
class Solution {
public:
string reverseLeftWords(string s, int n) {
if (s.size() == 1) return s;
reverse(s, 0, n - 1);
reverse(s, n, s.size() - 1);
reverse(s, 0, s.size() - 1);
return s;
}
void reverse(string& s, int start, int end) {
for (int i = start, j = end; i < j; ++i, --j) {
swap(s[i], s[j]);
}
}
};
2、滑动窗口(双指针),全面总结见数组笔记
3. 无重复字符的最长子串 - 力扣(LeetCode)
思路:
双指针 的最难版本,滑动窗口
辅助数据结构用unordered_map,map内始终维护着不重复的子串
未遇到重复元素,right++不断扩大窗口,若map中出现重复元素,left++减小窗口直到重复元素被删除
扩大窗口和缩小窗口的操作对称
class Solution {
public:
int lengthOfLongestSubstring(string s) {
if (s.size() == 0) return 0;
unordered_map<char, int> window;
// 双指针
int left = 0, right = 0;
int result = 0;
while (right < s.size()) {
// 未遇到重复字符串就一直加,right右移
char c = s[right];
right++;
window[c]++;
// 有重复left左移直到删除该重复的字符串
while (window[c] > 1) {
char d = s[left];
left++;
window[d]--;
}
// 收缩完后肯定剩下不重复的字串,记录长度
result = max(result, right - left);
}
return result;
}
};
3、KMP算法,还算双指针
KMP勉强算是双指针的另一种应用,主要思想是 当出现字符串不匹配时,可以知道一部分之前已经匹配的文本内容,可以利用这些信息避免从头再去做匹配了 ,关键是求前缀表next数组,其中 包含起始位置到下标i之前(包括i)的子串中,有多大长度的相同前缀后缀 ,也可以理解为回退的位置
前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串。
后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。
KMP算法主要解决匹配问题和重复字串问题
28. 找出字符串中第一个匹配项的下标 - 力扣(LeetCode)
思路:先根据模式串构造next数组,再根据next数组,比较文本串和模式串
其实是手动实现C语言中的strstr()函数
C 库函数 char *strstr(const char *haystack, const char *needle) 在字符串 haystack 中查找第一次出现字符串 needle 的位置,不包含终止符 ‘\0’。
class Solution {
public:
// const&防止传值时拷贝构造函数的调用开销,即不希望改变、不希望拷贝
void getNext(int* next, string s) {
// 双指针,j指向前缀末尾位置,i指向后缀开头位置
int j = 0;
next[0] = j;
// 后缀定义不包含首元素,从下标1开始
for (int i = 1; i < s.size(); ++i) {
// 不匹配时,一直后退到匹配
while (j > 0 && s[i] != s[j]) { // j必须大于0,因为后面要-1
j = next[j - 1];
}
// 匹配时,累加公共前后缀串长度,i、j后移
if (s[i] == s[j]) {
++j;
}
// next记录相同前后缀的长度
next[i] = j;
}
}
int strStr(string haystack, string needle) {
// if (needle.size() == 0) return 0;
int next[needle.size()];
getNext(next, needle);
int j = 0; // 与next[0]初始值相同
for (int i = 0; i < haystack.size(); ++i) {
// 利用next数组进行匹配
while (j > 0 && haystack[i] != needle[j]) {
j = next[j - 1];
}
if (haystack[i] == needle[j]) {
++j;
}
// needle全部被匹配了,返回其在haystack中下标
if (j == needle.size()) return (i - j + 1);
}
return -1;
}
};
459. 重复的子字符串 - 力扣(LeetCode)
KMP解法思路:next数组中本就是存储着最长相等前后缀长度。如果打印出next数组,会发现,如果s由若干t组成,next中的最后一个元素的值,也是最长相等前后缀长度,一定与s串相差一个循环单位t的长度。可利用这点,先构造next数组,然后进行判断
class Solution {
public:
void getNext(int* next, string s) {
int j = 0;
next[0] = j;
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;
}
}
bool repeatedSubstringPattern(string s) {
int next[s.size()];
getNext(next, s);
// next[s.size() - 1] != 0说明有最长相同的前后缀,且与s差一个循环单位长度
if (next[s.size() - 1] != 0 && s.size() % (s.size() - next[s.size() - 1]) == 0) return true;
return false;
}
};
移动匹配思路:若s由若干t组成,那么拼接后的s+s,不算头尾,必定能在中间段找出s。以此进行判断。用到了重载运算符+,用到了库函数erase,find,用到了迭代器,用到了size_t最大值string::npos
class Solution {
public:
bool repeatedSubstringPattern(string s) {
string t = s + s;
t.erase(t.begin());
t.erase(t.end() - 1);
if (t.find(s) != string::npos) return true;
return false;
}
};