KMP算法
解决字符串匹配的问题，时间复杂度为m+n
例如：
文本串：aabaabaaf
模式串：aabaaf
原理
按照上例，当模式串与文本串出现不匹配之后，即
模式串：aabaabaaf
文本串：aabaaf
此时模式串的不会跳转到开头重新开始匹配，而是会跳转到b的位置开始匹配，减少了回溯
模式串是如何跳转的？
根据前缀表来进行跳转，找到之前已经匹配过的内容，即是要找到一个字符串字符的最长的相等前后缀，这样在我们遇到不匹配的位置时，根据前缀表的位置开始跳转，例如
模式串：aabaabaaf
文本串：aabaaf
我们需要找到f之前a的最长相等前后缀，其最长相等前后缀为aa，因此跳转到为2位置b重新开始匹配
前缀与后缀
前缀：包含首字母不包含尾字母的所有子串
例如：aabaaf
前缀为：a,aa,aab,aaba,aabaa，aabaaf不是前缀，不能包含尾字母f
后缀：只包含尾字母不包含首字母的所有子串
例如：aabaaf
后缀为：f,af,aaf,baaf,abaaf, aabaaf不是后缀，因此不能包含首字母a
最长相等前后缀的长度
模式串：aabaaf
a：无前缀也无后缀，最长相等前后缀为0
aa：前缀为a，后缀也为a，因此相等前后缀为a，长度为1
aab：前缀为aa，a，后缀为ab，b，没有相等的前后缀，长度为0
aaba：前缀为a,aa,aab,后缀为a,ba,aba,最长相等前后缀为a，长度为1
aabaa：前缀为a,aa,aab,aaba,后缀为a,aa,baa,abaa,最长相等前后缀为aa，长度为2
aabaaf: 前缀为a,aa,aab,aaba,aabaa,后缀为f,af,aaf,baaf,abaaf,没有相等前后缀，长度为0
由上就可以得出前缀表
0,1,0,1,2,0
前缀表的工作模式
模式串：aabaabaaf
文本串：aabaaf
前缀表：010120
当我们在f时发现出现了不匹配，则我们在f的前面查找到其最长相等前后缀的值，其最长相等前后缀的值就记录在a的位置，即2，意味着这里有一个后缀aa，前面也有一个与之相等的前缀的aa，我们在a之后f发现了冲突，则我们就可以查找到与其相等的前缀（aa）的后面（b）再次开始匹配，此时其下标就为这个字符串的最长相等前后缀的长度，因为我们需要跳转到前缀的后面，而数组下标从0开始，因此跳转到的下标就为最长相等前后缀的长度
此时就不需要再从头开始查找
next数组
next数组就是前缀表，在我们遇见了冲突之后，next数组告诉我们需要回退到哪个位置重新开始匹配
next数组的实现
模式串： aabaaf
前缀表： 010120 ， 遇见冲突时查看的是next数组冲突前一位的值
整体右移：-101012 ，遇见冲突时直接查看next数组冲突位的数值
使用前缀表实现求next数组：
1.定义一个函数来求next数组，需要传入next数组进行赋值，传入模式串
2.初始化next的数组以及变量，需要两个变量，一个指向前缀末尾的位置j,一个指向后缀末尾位置i，j不光指向了前缀末尾的位置，还代表着i包括i之前的子串的最长相等前后缀的长度，j应该初始化为0，前缀由0开始，next数组在0的位置应该回退到0，即next[0]=0,i需要初始化为1，因为我们要比较前缀和后缀所对应的字符是否相等，则i应该从1开始
2.处理前后缀不相同的情况，当两者不匹配，则j应该向前回退，j应该看它前一位所对应的next数组的值就是其所要回退的下标，我们要看前一位是因为我们在求前缀表时也是看前一位的值，即j = next[j-1]，注意j回退时的边界，不能导致负数，因此要保障j>0,注意j的回退是一个连续的过程
3.处理前后缀相同的情况，如果j此时为0，那么j应该做+1的操作，因为j不仅代表着前缀的末尾位置，还代表着i包括i之前这个子串的最长相等前后缀的长度，再更新next数组的值，此时i位置的next数组的值为j
代码实现：
void getnext(int *next , char *s) //传入next数组和模式串
{
//代表着指向前缀末尾的位置，以及i包括i之前最长相等前后缀的长度
int j = 0;
//代表着指向后缀末尾的位置
int i = 1;
//初始化next数组第一个元素为0
next[0] = 0;
for( ; i < strlen(s) ; i++)
{
//处理不相等的情况
//如果不相等，j进行连续的回退，要注意j的边界范围和j要回退的位置
while( s[i] != s[j] && j > 0)
j = next[j-1];
//处理相等的情况
if(s[i] == s[j])
j++; //更新j的值，因此j还代表着i包括i之前最长相等前后缀的长度
//更新next数组的值
next[i] = j;
}
}KMP算法的实现
思想：
首先对模式串进行判断，如果模式串为空，直接返回0
定义一个next数组，通过上述函数得到next数组的值
开始遍历文本串和模式串，如果发现文本串和模式串发生冲突，则模式串进行回溯，再重新进行比对，如果没有发生冲突，则更新模式串的位置
如果已经查找到模式串末尾，则返回模式串在文本串中的位置，否则返回-1
代码实现：
//计算next数组
void getnext(int *next , char *s) //传入next数组和模式串
{
//代表着指向前缀末尾的位置，以及i包括i之前最长相等前后缀的长度
int j = 0;
//代表着指向后缀末尾的位置
int i = 1;
//初始化next数组第一个元素为0
next[0] = 0;
for( ; i < strlen(s) ; i++)
{
//处理不相等的情况
//如果不相等，j进行连续的回退，要注意j的边界范围和j要回退的位置
while( s[i] != s[j] && j > 0)
j = next[j-1];
//处理相等的情况
if(s[i] == s[j])
j++; //更新j的值，因此j还代表着i包括i之前最长相等前后缀的长度
//更新next数组的值
next[i] = j;
}
}
//KMP实现
//传入文本串s1和模式串s2
int reach_str(char *s1 , char *s2)
{
//如果模式串为空
if(strlen(s2) == 0)
return 0;
//定义next数组并进行求值
int len = strlen(s2);
int next[len];
getnext(next , s2);
int j = 0; //标记模式串的位置
//开始遍历文本串
for(int i = 0 ; i < strlen(s1) ; i++)
{
//如果查找到文本串与模式串不相等，更新模式串比对的位置，进行回溯
while(j > 0 && s1[i] != s2[j])
j = next[j-1];
//如果查找到文本串与模式串字符相等，更新模式串字符的位置
if(s1[i] == s2[j])
j++;
//比对到模式串末尾，在文本串中找到了模式串
if(j == strlen(s2))
return (i - strlen(s2) + 1); // 返回模式串在文本串的位置
}
return -1; //代表没有在文本串中找到模式串的位置
}
28.找出字符串中第一个匹配项的位置
题目描述：
给你两个字符串
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 <= 104haystack和needle仅由小写英文字符组成
思路：
该题为字符串匹配问题，因此可以直接KMP算法进行解决
代码实现：
//计算next数组
void getnext(int *next , char *s)
{
int j = 0; //j代表着模式串前缀末尾的位置，也代表着i包括i之前最长相等前后缀的长度
int i = 1; //代表着模式串的后缀末尾的位置
next[0] = 0;//s的第一个字符无前缀也无后缀
//只要没有到s的末尾
for( ; i < strlen(s); i++)
{
//如果前缀末尾和后缀末尾不相同
while(s[i] != s[j] && j > 0 )
j = next[j-1]; //j进行回溯
//如果两者相同，更新j，因为j代表着next数组最长相等前后缀的长度
if(s[i] == s[j])
j++;
//更新next数组的值
next[i] = j;
}
}
int strStr(char* haystack, char* needle) {
//如果模式串为空
if(strlen(needle) == 0)
return 0;
int j = 0; //模式串的位置
//获取next数组
int len = strlen(needle);
int next[len];
getnext(next,needle);
//遍历模式串和文本串
for(int i = 0; i < strlen(haystack) ; i++)
{
//如果模式串和文本串发生冲突，模式串回溯
while( haystack[i] != needle[j] && j > 0)
j = next[j-1];
//没有发生冲突，更新模式串的位置
if(haystack[i] == needle[j])
j++;
//查找到模式串末尾，代表模式串之前的位置全部都没有与文本串发生冲突
if(j == len)
return i-len+1; //返回模式串在文本串中的位置
}
return -1; //没有查找到
}459.重复的子字符串
题目描述：
给定一个非空的字符串
s，检查是否可以通过由它的一个子串重复多次构成。示例 1:
输入: s = "abab" 输出: true 解释: 可由子串 "ab" 重复两次构成。示例 2:
输入: s = "aba" 输出: false示例 3:
输入: s = "abcabcabcabc" 输出: true 解释: 可由子串 "abc" 重复四次构成。 (或子串 "abcabc" 重复两次构成。)提示：
1 <= s.length <= 104s由小写英文字母组成
暴力解法：
使用两层for循环嵌套，外层for循环查找子串的结束位置，内层for循环去进行子串与主串进行比较，时间复杂度为n^2
移动匹配：
任何一个重复子串组成的字符串，其前半部分与后半部分肯定是相等的，不一定需要从字符串中间划分，因此可以复制一个相同的字符串，将其相加起来，如果相加起来的字符串中出现了原字符串，那么该字符串就是由重复子串组成的，注意，两个字符串相加之后要删除掉首字符和尾字符，否则一定会出现原字符串，进行搜索没有意义
KMP算法实现：
如果一个字符串是由重复子串组成的，那么它的最小组成单位就是他的最长相等前后缀不包含的那一部分，不包含的那一个子串
例如 abababab
最长相等前缀 ababab
最长相等后缀 ababab
此时不包含的部分就是ab，则ab就是重复的子串
解法：
通过next数组查找到最大的值，即最大相等前后缀的长度，原字符串的长度减去此长度，如果原字符串剩余的长度如果能被原字符串的长度整除，则代表着该字符串是由重复子串组成的
代码：
void getnext(int *next , char *s)
{
int j = 0;
next[0] = 0;
for( int i = 1 ; i < strlen(s) ; i++)
{
while(s[i] != s[j] && j > 0)
j = next[j-1];
if(s[i] == s[j])
j++;
next[i] = j;
}
}
bool repeatedSubstringPattern(char* s) {
if(strlen(s) == 0)
return false;
int next[strlen(s)];
getnext(next,s);
int len = strlen(s);
//字符串最大相等前后缀判断
if(next[len-1] != 0 && len % (len - next[len-1]) == 0)
return true;
return false;
}总结
此次练习能够更为熟练的对双指针进行使用，但对于kmp算法还是不能熟练使用，需要在下次练习时加深理解
435
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
