28. 找出字符串中第一个匹配项的下标
1.题目介绍
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。
示例 1：
输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。
示例 2：
输入：haystack = "leetcode", needle = "leeto"
输出：-1
解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。
提示：
1 <= haystack.length, needle.length <= 104
haystack 和 needle 仅由小写英文字符组成
2.题解
2.1 使用find函数
思路
这题实际上是想让你手动实现find函数的功能，所以看2.2吧，QAQ
代码
class Solution {
public:
int strStr(std::string haystack, std::string needle) {
size_t pos = haystack.find(needle); // 使用find函数查找needle在haystack中的位置
if (pos != std::string::npos) {
return static_cast<int>(pos); // 找到匹配项，返回位置
} else {
return -1; // 未找到匹配项
}
}
};
2.2 暴力匹配（Bruce-Force算法）【回溯算法】
思路
简单的模式匹配算法是一种带回溯的匹配算法,算法的基本思想是:从主串S的第pos个字符开始,和模式串T的第一个字符开始比较,如果相等,就继续比较后续字符,如果不等,则从(回溯到)主串S的第pos+1个字符开始重新和模式串T比较,直到模式串T中的每一个字符和主串S中的一个连续字符子序列全部相等,则称匹配成功,返回和T中第一个字符相等的字符在主串S中的位置;或者主串中没有和模式串相等的字符序列,则称匹配不成功。
代码
haystack 和 needle 均从开头开始遍历，若是某次匹配不成功，则将haystack上的指针向后推一个，再重复上述步骤，直到 haystack 剩余长度等于 needle 长度！
class Solution {
public:
int strStr(string haystack, string needle) {
int n = haystack.size(), m = needle.size();
for (int i = 0; i + m <= n; i++) {
bool flag = true;
for (int j = 0; j < m; j++) {
if (haystack[i + j] != needle[j]) {
flag = false;
break;
}
}
if (flag) {
return i;
}
}
return -1;
}
};
2.3 KMP算法
思路
一.为何要使用next数组
利用已经部分匹配的结果而加快模式串的滑动速度,且主串S的指针i不必溯！可提速到O(n+m).
我们希望在发生不匹配情况时，主串指针保持不动，但是子串指针不能直接回溯到首部，这样会漏掉一些中间情况导致最终结果错误
实际上子串指针应进行合理回溯，回溯到适当位置与主串指针上下对应，再继续进行匹配
例如：
BF算法下一次的指针：
KMP算法下一次的指针：
那么问题就到了我们的子串指针究竟回溯到什么位置呢？这里我们记录一个next数组，记录到遇到不匹配情况时应回溯的位置
如上图，这里涉及到一个前缀和后缀的概念，
字符串的前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串；
后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。
公共前后缀则是二者的交集。
例如对于字符串 abacaba，
其前缀有 a, ab, aba, abac, abacab，
后缀有bacaba, acaba, caba, aba, ba, a。
最长公共前后缀就是 aba。
如果我们不匹配位置的前面位置构成的子串有着最长前后缀，我们可以将旧的最长公共后缀作为新匹配的前缀，
因为前后缀相同，并且均已匹配主串相应位置，我的模式串原匹配的主串作为后缀的位置，现在使用模式串的前缀也定可以匹配。
比如像：
模式串：abcaabcb
主串： abcaabcac...
这里在模式串最后一个字符不匹配，该字符前面的子串为abcaabc,有着最长前后缀abc(即[0:j] = [i-j:i]相同)
这时我们可以直接认为模式串已经匹配了一个主串的后缀到了上一次不匹配字符的位置，指针直接回溯到位置[i-j]
类似 |
abcaabcb
abcaabcac....
(因为我们主串指针停留在当前位置a，若要子串能接上直到这个字符a，前面的前缀一定要全部匹配，才能到达这个字符嘛，其中每次选择的前缀最长时，也就能覆盖所有情况)
二.next数组的建立
这里为了方便，使next数组索引从0开始，i和j的初始值也赋为了0和-1。
整体思路是将子串看做一个主串，i左边的所有的字符看做一个模式串，找相等的最长前后缀
-
j==-1：
1.1 主串当前位置与子串第一个位置都不匹配，然后 j = next[0] = -1,之后++i, ++j，相当于子串重头开始，主串向后跳跃一个 -
str[j] != str[i]: 这时候最长前缀[0:j-1]的后一个位置 和 最长后缀[i-1-(j-1):i-1]的后一个位置值并不匹配，这里的选择很巧妙
我们之前说了主串和模式串不匹配，就将模式串指针回溯即可，这里我们相当于一边求next数组的同时一边又利用了之前求得的next数组 -
这里由于++i和++j，所以if判断中的str[i] == str[j]判断的是最长前缀末尾和最长后缀末尾是否相同；而next[i] = j;中的i则是潜在的失配位置i和回溯位置j
比如像abcabxxxxxx这里 j=1,i=4;判断的是前缀和后缀； 进入之后++i,++j; next[i] = j;说明的是如果第一个x那里失配了，子串指针回溯到c的位置
代码
class Solution {
private:
void get_next(string str, vector<int>& next){
int i = 0, j = -1;
next[0] = -1; // 初始化next数组，这里为了方便统一为下标，跟上图中从1开始不同，这里选择从0开始
while(i < str.length()){
if(j == -1 || str[i] == str[j]){
++i;
++j;
next[i] = j;
} else {
j = next[j];
}
}
}
public:
int strStr(string haystack, string needle) {
int hLen = haystack.length(), nLen = needle.length();
if (nLen == 0) return 0;
vector<int> next(nLen + 1, 0); // 将next数组大小设为nLen+1，避免越界
get_next(needle, next);
int pos = 0, tp = 0;
while(pos < hLen && tp < nLen){
if(tp == -1 || haystack[pos] == needle[tp]){
++pos;
++tp;
} else {
tp = next[tp];
}
}
if(tp == nLen) return pos - nLen;
else return -1;
}
};
2.4 KMP算法(next数组改进)
思路
上述步骤可能存在的问题：
存在多个重复连续字符，当前字符无法匹配成功，往前回溯的所有重复字符必然也无法匹配成功，这里就要修改一下next数组的构成了
总体代码没有很多的改变，只是在其中加入了一小段if判断（回溯的点的值如果等于当前点的值，则继续回溯）
我们在求出next[i]值（j）时，要检验一下当前值str[i]和之后回溯的值str[next[i]] = str[j]是否一样，若一样则再回溯一次（由于顺序进行，这里再回溯一次都是建立在之前所有nextval都不存在重复元素的情况了，所以最多需要再回溯一次）
代码
class Solution {
private:
void get_next(string str, vector<int>& next, vector<int>& nextval){
int i = 0, j = -1;
next[0] = -1;
nextval[0] = -1;
while(i < str.length()){
if(j == -1 || str[i] == str[j]){
++i;
++j;
next[i] = j;
if(str[i] != str[j])
nextval[i] = j;
else
nextval[i] = nextval[j];
}
else{
j = nextval[j];
}
}
}
public:
int strStr(string haystack, string needle) {
int hLen = haystack.length(), nLen = needle.length();
if (nLen == 0) return 0;
vector<int> next(nLen+1, 0);
vector<int> nextval(nLen+1, 0);
get_next(needle, next, nextval);
int hPos = 0, nPos = 0;
while(hPos < hLen && nPos < nLen){
if(nPos == -1 || needle[nPos] == haystack[hPos]){
++nPos;
++hPos;
}
else nPos = nextval[nPos];
}
return nPos == nLen ? hPos - nLen : -1;
}
};
如果想要实际检验next数组和nextval数组的值，或是说方便调试，这里有一个完整KMP算法程序
#include <iostream>
#include <vector>
using namespace std;
class Solution {
private:
vector<int> next;
vector<int> nextval;
void get_next(string str) {
int i = 0, j = -1;
next[0] = -1;
nextval[0] = -1;
while (i < str.length()) {
if (j == -1 || str[i] == str[j]) {
++i;
++j;
next[i] = j;
//这里经过了++i,++j,所以str[i]和str[j]与if判断中的不一样，指的是失配位置和回溯位置，而不是最长前缀末尾和最长后缀末尾
if (str[i] != str[j]) {
nextval[i] = j;
} else {
nextval[i] = nextval[j];
}
} else {
j = nextval[j];
}
}
}
public:
int strStr(string haystack, string needle) {
int hLen = haystack.length(), nLen = needle.length();
if (nLen == 0) return 0;
next.resize(nLen);
nextval.resize(nLen);
get_next(needle);
int pos = 0, tp = 0;
while (pos < hLen && tp < nLen) {
if (tp == -1 || haystack[pos] == needle[tp]) {
++pos;
++tp;
} else {
tp = nextval[tp];
}
}
if (tp == nLen) return pos - nLen;
else return -1;
}
void printNextVectors() {
for (auto num : next) {
cout << num << ' ';
}
cout << endl;
for (auto num : nextval) {
cout << num << ' ';
}
cout << endl;
}
};
int main() {
Solution solution;
string haystack = "ababaabcacac";
string needle = "abaabcac";
int result = solution.strStr(haystack, needle);
solution.printNextVectors();
cout << result << endl; // Output: 2
return 0;
}
