09*：字符串匹配算法KMP算法：（主要是需要理解KMP中next数组求解的必要性以及j 的回溯依据;）（回溯j 值的多少取决于当前字符之前的串前后缀相似度;）
问题
目录
1：什么是KMP
2：KMP算法原理
预备
正文
1：什么是KMP
KMP算法是在字符串匹配算法中比较绕的.主要是需要理解KMP中next数组求解的必要性以及j 的回溯依据;
KMP 算法 是由 D.E.Knuth,J.H.Mores 和 VR.Pratt共同发表模式匹配算法,称之克鲁特-莫里斯-普拉特算法。简称 KMP 算法,可以大大避免重复遍历的情况
2：KMP 模式匹配算法原理
case1:
1：例如,假设现在有一个主串S = “aaacaaab” ; 模式串 T = “aaab” ; 如果使用暴风算法的话,前面5个字母完全相等,直到第6个字母.'f' 和 'x' 不相等; 如下图;
也就是说, 既然"a"不与自己后面的子串中任何一个字符相等. 那么对于上图中①来说,前面5个字符分别相等.那就意味着子串T与首字符"a"不可能与S 串的第2位到第5位想的.
KMP算法的想法是，设法利用这个已知信息，不要把"搜索位置"移回已经比较过的位置，继续把它向后移，这样就提高了效率。
3：理解KMP 关键
• 如果我们知道 T 串中的首字母"a" 与 T 中后面的字符均不相等(注意这是前提,如何判断后面会说明);
• 并且 T 串的第二位的 "b" 与 S 串中的第二位的 "b" 在第①图已经判断相等.
所以可以直接从第一步到第六步就可以的
之所以会保留第⑥次判断是因为在①中 T[6] != S[6],尽管我们已经知道T[1] != T[6]. 但是不能断定 T[1] 一定不等于 s[6].
case2:
例如,假设现在有一个主串S = “abcababca” ; 模式串 T = “abcdex” ;
• 对于开始的判断,前 5 个字符完全相等. 第6个字符不相等; 如果下图①
• 而且在第①次比较时, 第四位的 "a" 与 第五位的 "b" 已经与主串 S 中的相应位置比较过了.是相等的;
• 因此可以断定: T 的首字符 "a", 第二字符 "b" 与 S 的第四位字母"a" 和第五位字母"b" 不需要在做比较了. 肯定也是相等的.
• 所以④⑤的比较也是多余的
• 对比这2个例子中, 我们会发现 ① 时,我们的 i 值,就是主串当前位置的下是 6 ;
• ②③④⑤ ,i 的值是 2,3,4,5, 到了 ⑥ 时,i 值又回到了6.
• 当我们在暴风匹配算法中, 主串的 i 值是不断地回溯来完成的;
• 而在刚刚的分析中,有很多不必要的回溯;
• 而KMP 算法就是为了让不必要的回溯发生!
既然 i 值不能回溯, 也不可以变小; 那么考虑的变化就是 j 值;
通过刚刚的分析了解,我们屡次提到了 T 串的首字符 与自身后面字符的比较; 发现如果有相等字符, j值的变化就会不相同; 也就是说, j 值的变化其实与主串的关系. 更多取决于T串中的结构是否有重复问题;
case3:字符串中重复的字符比较多，该算法就显得很蠢。
比如 txt = "aaacaaab" pat = "aaab"：
暴风算法
KMP算法
• case1中：由于 T = "abcdex" 当中没有重复的数字, 所以 j 就由 6 变成了1;
• case2中：由于 T = "abcabx". 前缀 "ab" 与最后的"x" 之前串的后缀 "ab" 是相等的. 所以就 j 就由 6 变成了 3;
因此得出规律:j 值的多少取决于当前字符之前的串前后缀相似度;
KMP匹配算法中_next 数组值推导
情况1: 模式串中无任何字符重复
因为模式串每一个元素都不想等，所以只要主串不匹配的时候只能从第一个位置开始再次匹配
情况2: 模式串类似于 "abcabx"
• 当j=5，1到j-1范围内只有字符“abca”，显然前缀a和后缀a想等，属于其他情况next[5]=2
因为当主串匹配到第五个元素b的时候，说明b的前面也就是第四位的元素一定是a，不然肯定不会匹配到第五个元素，所以假设当第五个元素不匹配的时候，模式串可以从第二个元素开始与主串的第五个元素进行重新匹配
• 当j=6，1到j-1范围内只有字符“abcab”，显然前缀ab和后缀ab想等，属于其他情况next[6]=3
因为当主串匹配到第六个元素x的时候，说明x的前面也就是第四位和第五位的元素一定是ab，不然肯定不会匹配到第六个元素，所以假设当第六个元素不匹配的时候，模式串可以从第三个元素开始与主串的第六个元素进行重新匹配，因为主串的第四个和第五个元素一定和模式串的第一个和第二个元素相等
同时需要注意的是:
next数组是比较连续的前缀字符和后缀字符; 例如当j=6时,字符串"ababa", 最大前缀是"aba",后缀也是"aba". 当 j = 7时,字符串"ababaa",此时前缀是"a",后缀是"a". 不要误以为是"ab";
情况3: 模式串类似于 "aaaaaaaab"
重叠的情况下，前缀和后缀可以共用
计算子串T的next数组:求解next数组其实就是在求解字符串的回溯位置;
KMP next数组的回溯位置求解过程模拟
• 假设, 主串S = “abcababca” ; 模式串 T = “abcdex”
• 根据刚刚的公式的推演过程,我们其实非常情况next数组的应该是 011111 . 但是我们如何利用代码来求解出next数组了?
• 011111,意味着什么.
• 意味着其实模式串中abcdex 根本没有可以便于回溯的地址.也就是当主串与模式串不匹配时,都需要从第1的位置上重新比较;
• 模式串的索引j当时等于4. 而此时发现不匹配,则要进行回溯. 那么应该回溯到哪里了?
• j = next[j] ; j = 1; 也就是把abcbabca 的第4个字符与模式串的第1个字符串重新开始比较;
1⃣️ 默认next[1] = 0
2⃣️ i= 0，j=1开始遍历
3⃣️ 当j<s.length j从1～length遍历字符串
4⃣️ 如果当i = 0 表示[ i , j ] 这个范围内没有找到相同的字符，所以i要回溯到1的位置；表示next[j] = 1
5⃣️ 如果当T[i] = T[j] 相等，表示找到了相等的字符的位置吗所以next[j] = i ;
6⃣️ 当以上两个条件都不成立的时候，则将i回溯到前面记录的位置的next[i]的位置
• 首先默认next[1] = 0; 表示它需要从0开始遍历;
• 接下来设计2个索引下标 i = 0, j = 1;
• i 用于求解回溯的地址, 而j用于模式串的遍历
• 如果出现 i = 0,就是表示此时在模式串中并没有出现它相同的字符, 需要记录此时的回溯地址地址为1; next[j] = 1; 表示需要把• 从模式串的第一个字符开始比较;
• 如果T[i] == T[j] 表示此时已经出现了模式串中有重叠字符,则回溯地址next[j] = i;
• 如果既没有出现 i = 0,且 T[i] == T[j] 表示此时从[i,j]这个范围没有出现回溯位置的调整,我们则把 i 回溯到next[i] 的位置;
• 而这是只有字母 a,并且当前 i = 0, 所以如果主串和模式串匹配是,遇到第2个字符就不相配. 那么就应该讲主串后移1位,并且与模式串重新的第1位开始重新匹配计算;
• 但是此时i=0,j = 1; 所以我们应该i++,j++;
• 并且将next[j] = i; 所以此时`next[2] = 1;
• 表示,当j=2时,发现字符不匹配.需要把控制模式串比较的下标索引回溯到1. 从第一个字符重新开始比较;
• 所以将i回退到next[1]. 也就是 i = next[i];
• 那么如果i = 1,next[1] = 0;也就是0的位置; 0就意味着我们需要下一个字符进行比较时,我们需要头开始比较;
• 那么如果是 next[i] 等于其他位置,表示把i回溯到其他位置. 而只有i有可回溯的可能性才会回溯到其他位置.
• 那么头的位置指的是 1. 所以i++,j++; 因为这是当j = 3时, 如果不匹配需要回溯到开始的位置. 所以j 也是要➕➕ 的;
• 同时next[j] = i; next[3] = 1;
在求解next数组的4种情况:
- 默认next[1] = 0;
- 当 i=0时,表示当前的比应该从头开始.则i++,j++,next[j] = i;
- 当 T[i] == T[j] 表示2个字符相等,则i++,j++.同时next[j] = i;
- 当 T[i] != T[j] 表示不相等,则需要将i 退回到合理的位置. 则 i = next[i];
那么 next 数组如何应用到KMP 的查找中了?
KMP匹配算法优化
KMP 算法也是有缺陷的. 比如,如果我们的主串 ,模式串
. 其中 next 数组就是
;
• 当开始匹配时, 当 i = 5, j = 5 时, 我们发现字符 "b" 与 字符 "a" 不相等时, 如图① . 因此 j = next[5] = 4.
以此类推. 如图④⑤; 当 j = next[1] = 0时,根据算法,此时 i++,j++; 得到i = 6,j = 1. 如图⑥;
其实,在比较的过程发现 当中②③④⑤步骤的回溯比较都是多余的判断;
由于 T 串的第二,三,四,五位置的字符都与首位 "a" 相等, 那么可以用 首位 next[1] 的值去取代与它相等的字符后续的 next[j] 值. 那么我们来对 next 函数来进行改良;
next 数组= {0,1,2,3,4,5}
如果要节省刚刚 ②③④⑤ 的无效比较则 需要next 数组={0,0,0,0,0,5}
KMP 模式匹配next 数组的优化
• 当 j = 2时, 也就是当j = 2发生匹配错误, 那么由于第二个字符'b'的 next 值是1, 而且第一个字符是'a' .两者不相等.所以nextval[2] = next[2] = 1;
• 当 j = 3 时, 此时因为第 3 个字符 'a' 的 next 值是1, 所以得知 第1位的'a' 与 第3位的'a' 是相等,则此时nextVal[3] = nextVal[1] = 0;
• 当j = 4 时, 因为第 4 个字符 "b" 的next = 2; 所以可以得知 它与第 2 位字符 "b" 是相等,则nextVal[4] = nextVal[2] = 1;
KMP思路
KMP思路: 1. 遍历模式串S,i 是用来标记主串的索引; 遍历模式串T, j 是用来标记模式串的索引; 2. 结束条件是当i > S.length 和 j > T.length; (1)如果 i > S.length 但是j 却小于T.length 表示遍历了整个主串,都没有找到与模 式串匹配的情况 (2)只有1种可能,就是j > T.length 表示,已经在主串中找到模式串了. 因为你已经顺 利的把T模式串中的每个字符串正常的依次比较下去了,直到它结束; 3. 当 j = 0 时,表示此时你需要将模式串从1这个位置与主串i+1这个位置开始比较; 4. 当 T[i] == T[j], 表示此时当前模式串j 与 主串i 这个2个字符是相等,则j++,i++; 5. 当 j != 0 并且T[i] != T[j] 时,表示此时需要移动模式串的 j ,那么我们让 j = next[j]; 来节省重复的比较次数;
KMP_NextVal 数组逻辑
KMP_NextVal 数组逻辑 在求解nextVal数组的5种情况: 默认nextval[1] = 0; T[i] == T[j] 且++i,++j 后 T[i] 依旧等于 T[j] 则 nextval[i] = nextval[j] i = 0, 表示从头开始i++,j++后,且T[i] != T[j] 则nextVal = j; T[i] == T[j] 且++i,++j 后 T[i] != T[j] ,则nextVal = j; 当 T[i] != T[j] 表示不相等,则需要将i 退回到合理的位置. 则 i = next[i];
代码实现
#include "string.h" #include "stdio.h" #include "stdlib.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 /* 存储空间初始分配量 */ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int ElemType; /* ElemType类型根据实际情况而定，这里假设为int */ typedef char String[MAXSIZE+1]; /* 0号单元存放串的长度 */ //----字符串相关操作--- /* 生成一个其值等于chars的串T */ Status StrAssign(String T,char *chars) { int i; if(strlen(chars)>MAXSIZE) return ERROR; else { T[0]=strlen(chars); for(i=1;i<=T[0];i++) T[i]=*(chars+i-1); return OK; } } Status ClearString(String S) { S[0]=0;/* 令串长为零 */ return OK; } /* 输出字符串T。 */ void StrPrint(String T) { int i; for(i=1;i<=T[0];i++) printf("%c",T[i]); printf("\n"); } /* 返回串的元素个数 */ int StrLength(String S) { return S[0]; } //----KMP 模式匹配算法--- //1.通过计算返回子串T的next数组; //注意字符串T[0]中是存储的字符串长度; 真正的字符内容从T[1]开始; void get_next(String T,int *next){ int i,j; j = 1; i = 0; next[1] = 0; //abcdex //遍历T模式串, 此时T[0]为模式串T的长度; //printf("length = %d\n",T[0]); while (j < T[0]) { //printf("i = %d j = %d\n",i,j); if(i ==0 || T[i] == T[j]){ //T[i] 表示后缀的单个字符; //T[j] 表示前缀的单个字符; ++i; ++j; next[j] = i; //printf("next[%d]=%d\n",j,next[j]); }else { //如果字符不相同,则i值回溯; i = next[i]; } } } //输出Next数组值 void NextPrint(int next[],int length) { int i; for(i=1;i<=length;i++) printf("%d",next[i]); printf("\n"); } int count = 0; //KMP 匹配算法(1) //返回子串T在主串S中第pos个字符之后的位置, 如不存在则返回0; int Index_KMP(String S,String T,int pos){ //i 是主串当前位置的下标准,j是模式串当前位置的下标准 int i = pos; int j = 1; //定义一个空的next数组; int next[MAXSIZE]; //对T串进行分析,得到next数组; get_next(T, next); count = 0; //注意: T[0] 和 S[0] 存储的是字符串T与字符串S的长度; //若i小于S长度并且j小于T的长度是循环继续; while (i <= S[0] && j <= T[0]) { //如果两字母相等则继续,并且j++,i++ if(j == 0 || S[i] == T[j]){ i++; j++; }else{ //如果不匹配时,j回退到合适的位置,i值不变; j = next[j]; } } if (j > T[0]) { return i-T[0]; }else{ return -1; } } //KMP 匹配算法(2) //求模式串T的next函数值修正值并存入nextval数组中; void get_nextVal(String T,int *nextVal){ int i,j; j = 1; i = 0; nextVal[1] = 0; while (j < T[0]) { if (i == 0 || T[i] == T[j]) { ++j; ++i; //如果当前字符与前缀不同,则当前的j为nextVal 在i的位置的值 if(T[i] != T[j]) nextVal[j] = i; else //如果当前字符与前缀相同,则将前缀的nextVal 值赋值给nextVal 在i的位置 nextVal[j] = nextVal[i]; }else{ i = nextVal[i]; } } } //KMP 匹配算法(2) //返回子串T在主串S中第pos个字符之后的位置, 如不存在则返回0; int Index_KMP2(String S,String T,int pos){ //i 是主串当前位置的下标准,j是模式串当前位置的下标准 int i = pos; int j = 1; //定义一个空的next数组; int next[MAXSIZE]; //对T串进行分析,得到next数组; get_nextVal(T, next); count = 0; //注意: T[0] 和 S[0] 存储的是字符串T与字符串S的长度; //若i小于S长度并且j小于T的长度是循环继续; while (i <= S[0] && j <= T[0]) { //如果两字母相等则继续,并且j++,i++ if(j == 0 || S[i] == T[j]){ i++; j++; }else{ //如果不匹配时,j回退到合适的位置,i值不变; j = next[j]; } } if (j > T[0]) { return i-T[0]; }else{ return -1; } } int main(int argc, const char * argv[]) { // insert code here... printf("Hello, KMP匹配算法实现!\n"); int i,*p,*t; String s1,s2; int Status; /*关于next数组的求解*/ StrAssign(s1,"aaaaax"); printf("子串为: "); StrPrint(s1); i=StrLength(s1); p=(int*)malloc((i+1)*sizeof(int)); get_next(s1,p); printf("Next为: "); NextPrint(p,StrLength(s1)); t=(int*)malloc((i+1)*sizeof(int)); get_nextVal(s1, t); printf("NextVal为: "); NextPrint(t,StrLength(s1)); printf("\n"); //KMP算法调用 StrAssign(s1,"abcababca"); printf("主串为: "); StrPrint(s1); StrAssign(s2,"abcdex"); printf("子串为: "); StrPrint(s2); Status = Index_KMP(s1,s2,1); printf("主串和子串在第%d个字符处首次匹配（KMP算法）[返回位置为负数表示没有匹配] \n",Status); Status = Index_KMP2(s1, s2, 1); printf("主串和子串在第%d个字符处首次匹配（KMP_2算法）[返回位置为负数表示没有匹配] \n\n",Status); StrAssign(s1,"abccabcceabc"); printf("主串为: "); StrPrint(s1); StrAssign(s2,"abcce"); printf("子串为: "); StrPrint(s2); Status = Index_KMP(s1,s2,1); printf("主串和子串在第%d个字符处首次匹配（KMP算法）[返回位置为负数表示没有匹配] \n",Status); Status = Index_KMP2(s1, s2, 1); printf("主串和子串在第%d个字符处首次匹配（KMP_2算法）[返回位置为负数表示没有匹配] \n\n",Status); StrAssign(s1,"aaaabcde"); printf("主串为: "); StrPrint(s1); StrAssign(s2,"aaaaax"); printf("子串为: "); StrPrint(s2); Status = Index_KMP(s1,s2,1); printf("主串和子串在第%d个字符处首次匹配（KMP算法）[返回位置为负数表示没有匹配] \n",Status); Status = Index_KMP2(s1, s2, 1); printf("主串和子串在第%d个字符处首次匹配（KMP_2算法）[返回位置为负数表示没有匹配] \n\n",Status); return 0; }
注意
