模式匹配KMP算法思想和实现
kmp
这个程序或许比想像中的要简单，因为对于i值的不断增加，代码用的是for循环。因 此，这个代码可以这样形象地理解：扫描字符串A，并更新可以匹配到B的什么位置。 思考，那个while循环能保证是常数级么？ p数组怎么求出来？
对于while循环的分析
为什么这个程序是O(n)的？其实，主要的争议在于，while循环 使得执行次数出现了不确定因素。我们将用到时间复杂度的摊还 分析中的主要策略，简单地说就是通过观察某一个变量或函数值 的变化来对零散的、杂乱的、不规则的执行次数进行累计。KMP 的时间复杂度分析可谓摊还分析的典型。我们从上述程序的j 值入 手。每一次执行while循环都会使j减小（但不能减成负的），而另 外的改变j值的地方只有第五行。每次执行了这一行，j都只能加1； 因此，整个过程中j最多加了n个1。于是，j最多只有n次减小的机 会（j值减小的次数当然不能超过n，因为j永远是非负整数）。这 告诉我们，while循环总共最多执行了n次。按照摊还分析的说法， 平摊到每次for循环中后，一次for循环的复杂度为O(1)。整个过程 显然是O(n)的。这样的分析对于后面P数组预处理的过程同样有效， 同样可以得到预处理过程的复杂度为O(m)。
kmp
本ppt大部分来自网络 matrix67
思路来源
pascal里有个叫 pos的 string 函数。 cpp里string类里有个find成员函数 有两个串A和B（length(A)>=length(B)），我们要找B 在A中第一次出现的位置。 如果没有pos，怎么办？ 最裸的。 通常我们的方法是枚举从A串的什么位置起开始与B 匹配，然后验证是否匹配。假如A串长度为n，B串长 度为m，那么这种方法的复杂度是O (mn)的。 有人会说只要有不匹配就可以break，那样不会到m*n。
串的模式匹配算法
串串（String）又叫做字符串，是一种特殊的线性表的结构，表中每一个元素仅由一个字符组成。
随着计算机的发展，串在文字编辑、词法扫描、符号处理以及定理证明等诸多领域已经得到了越来越广泛的应用。
第一节串的定义和表示1、串的逻辑结构定义串是由零个到任意多个字符组成的一个字符序列。
一般记为：S=’ a1a2a3……a n’(n>=0)其中S为串名，序列a1a2a3……a n为串值，n称为串的长度，我们将n=0的串称为空串(null string)。
串中任意一段连续的字符组成的子序列我们称之为该串的子串，字符在序列中的序号称为该字符在串中的位置。
在描述中，为了区分空串和空格串(s=‘’)，我们一般采用来表示空串。
2、串的基本操作串一般包含以下几种基本的常用操作：1、length(S)，求S串的长度。
2、delete(S,I,L)，将S串从第I位开始删除L位。
3、insert(S,I,T)，在S的第I位之前插入串T。
4、str(N,S)，将数字N转化为串S。
5、val(S,N,K)，将串S转化为数字N；K的作用是当S中含有不为数字的字符时，K记录下其位置，并且S没有被转化为N。
3、串的储存结构一般我们采用以下两种方式保存一个串：1、字符串类型，描述为：const n=串的最大长度type strtype=string[n]这里由于tp的限制，n只能为[1..255]。
在fp或者delphi中，我们还可以使用另外一种类型，描述为：const n=串的最大长度type strtype=qstring[n]这里的n就没有限制了，只要空间允许，开多大都可以。
2、数组来保存，描述为：const n=串的最大长度type strtype=records:array[1..n] of char;len:0..n;end;第二节模式匹配问题与一般的线性表不同，我们一般将串看成一个整体，它有一种特殊的操作——模式匹配。
kmp算法next计算方法
kmp算法next计算方法KMP算法是一种用于字符串匹配的经典算法，它的核心在于利用已经部分匹配的信息来避免重复的比较，从而提高匹配的效率。
在KMP算法中，next数组的计算是非常关键的一步，它决定了算法的匹配效率和性能。
本文将详细介绍KMP算法中next数组的计算方法。
首先，我们需要了解什么是next数组。
在KMP算法中，next 数组是用来存储模式串中每个位置对应的最长公共前缀和最长公共后缀的长度的数组。
这个数组的作用在于，当模式串中的某个字符与文本串中的字符不匹配时，可以利用next数组中的信息来快速调整模式串的位置，从而避免不必要的比较。
接下来，我们来介绍如何计算next数组。
假设模式串为P，长度为m，我们要计算的是next数组的值。
首先，我们定义next[0]=-1，next[1]=0，这是因为长度为1的字符串没有真正的前缀和后缀。
然后，我们从位置2开始计算next数组的值。
具体的计算方法是，我们用两个指针i和j，其中i表示后缀的末尾位置，j表示前缀的末尾位置。
我们不断比较P[i]和P[j]，如果相等，则next[i+1]=j+1；如果不相等，则我们将j回溯到next[j]的位置，继续比较P[i]和P[j]，直到找到一个相等的位置或者j回溯到-1为止。
通过这样的计算方法，我们可以得到模式串P的next数组。
这个数组的计算过程虽然有些复杂，但是它的作用是非常重要的，可以大大提高KMP算法的匹配效率。
在实际应用中，我们可以将next数组的计算过程封装成一个函数，以便在KMP算法中直接调用。
这样可以使算法更加模块化和易于理解。
总结一下，KMP算法是一种高效的字符串匹配算法，而next数组的计算是KMP算法的关键步骤之一。
通过合理的计算方法和封装函数，我们可以更好地理解和应用KMP算法，从而提高字符串匹配的效率。
希望本文对你有所帮助，如果有任何疑问或者建议，欢迎留言讨论。
KMP算法next计算方法。
串的模式匹配问题实验总结（用C实现）
串的模式匹配问题实验总结（用C实现）第一篇：串的模式匹配问题实验总结(用C实现)串的模式匹配问题实验总结1实验题目：实现Index(S,T,pos)函数。
其中，Index(S,T,pos)为串T在串S的第pos个字符后第一次出现的位置。
2实验目的：熟练掌握串模式匹配算法。
3实验方法：分别用朴素模式匹配和KMP快速模式匹配来实现串的模式匹配问题。
具体方法如下：朴素模式匹配：输入两个字符串，主串S和子串T，从S串的第pos个位置开始与T的第一个位置比较，若不同执行i=i-j+2；j=1两个语句；若相同，则执行语句++i;++j;一直比较完毕为止，若S中有与T相同的部分则返回主串（S字符串）和子串（T字符串）相匹配时第一次出现的位置，若没有就返回0。
KMP快速模式匹配：构造函数get_next(char *T,int *next)，求出主串S串中各个字符的next值，然后在Index_KMP(char *S,char *T,int pos)函数中调用get_next(char *T,int *next)函数并调用next值，从S串的第pos 位置开始与T的第一个位置进行比较，若两者相等或j位置的字符next值等于0，则进行语句++i;++j;即一直向下进行。
否则，执行语句j=A[j]；直到比较完毕为止。
若S中有与T相同的部分则返回主串（S字符串）和子串（T字符串）相匹配时第一次出现的位置，若没有就返回04实验过程与结果：（1）、选择1功能“输入主串、子串和匹配起始位置”，输入主串S：asdfghjkl, 输入子串T：gh,输入pos的值为：2。
选择2功能“朴素的模式匹配算法”，输出结果为 5；选择3功能“KMP快速模式匹配算法”，输出结果为 5；选择0功能，退出程序。
截图如下：（2）、选择1功能“输入主串、子串和匹配起始位置”，输入主串S：asdfghjkl, 输入子串T：wp, 输入pos的值为：2。
kmp
2 KMP算法：KMP算法是由D.E.Knuth（克努特），J.H.Morris（莫里斯），V.R.Pratt（普拉特）等人共同提出的，该算法主要消除了主串指针(i指针)的回溯，利用已经得到的部分匹配结果将模式串右滑尽可能远的一段距离再继续比较，从而使算法效率有某种程度的提高，O(n+m)。
先从例子入手（p82）：按Brute-Force算法i=i-j+2=2-2+2=2,j=1按Brute-Force算法i=i-j+2=2-1+2=3,j=1按Brute-Force算法i=i-j+2=8-6+2=4,j=1,但从已匹配的情况看，模式串在t[6]即“c”前的字符都是匹配的，再看已匹配的串“abaab”,t[1]t[2]与t[4]t[5]相同，那么，因为t[4]t[5]与原串s[6]s[7]匹配，所以t[1]t[2]必然与原串s[6]s[7]匹配，因此说t[3]可以直接与s[8]匹配，按KMP 算法i=8,j=3匹配成功。
从上例看出在匹配不成功时，主串指针i不动，j指针也不回到第一个位置，而是回到一个恰当的位置，如果这时让j指针回到第一个位置，就可能错过有效的匹配，所以在主串指针i不动的前提下，j指针回到哪个位置是问题的关键，既不能将j右移太大，而错过有效的匹配，另一方面，又要利用成功的匹配，将j右移尽可能地大，而提高匹配的效率，因此问题的关键是寻找模式串自身的规律。
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////。
和直接比较若不满足和直接比较所以：满足：，设1i i 12112111112121s ),2(;s )1(""")"2(""")"1(""""t t j k t t t t t t t t s s t t t t s s s s k j k j k j k j i j i m n <<====-+-+----+-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////设s=” s 1 s 2 ... s n ”， t=” t 1 t 2 ... t m ”，在匹配过程中，当s i ≠ t j (1≤i ≤n-m+1,1≤j ≤m)时，存在（前面的j-1个字符已匹配）：” s i-j+1 ... s i-1 ” =” t 1 t 2 ... t j-1 ” (1) 若模式中存在可互相重叠的最长的真子串，满足： ” t 1 t 2 ... t k-1 ”=”t j-k+1 t j-k+2 ... t j-1 ” (2) 其中真子串最短可以是t 1 ，即 t 1。
KMP算法以及优化（代码分析以及求解next数组和nextval数组）
KMP算法以及优化（代码分析以及求解next数组和nextval数组）KMP算法以及优化(代码分析以及求解next数组和nextval数组)来了,数据结构及算法的内容来了,这才是我们的专攻,前⾯写的都是开胃⼩菜,本篇⽂章,侧重考研408⽅向,所以保证了你只要看懂了,题⼀定会做,难道这样思想还会不会么?如果只想看next数组以及nextval数组的求解可以直接跳到相应部分,思想总结的很⼲~~⽹上的next数组版本解惑先总结⼀下,⼀般KMP算法的next数组结果有两个版本,我们需要知道为什么会存在这种问题,其实就是前缀和后缀没有匹配的时候next数组为0还是为1,两个版本当然都是对的了,如果next数组为0是的版本,那么对于前缀和后缀的最⼤匹配长度只需要值+1就跟next数组是1的版本⼀样了,其实是因为他们的源代码不⼀样,或者对于模式串的第⼀个下标理解为0或者1,总之这个问题不⽤纠结,懂原理就⾏~~那么此处,我们假定前缀和后缀的最⼤匹配长度为0时,next数组值为1的版本,考研⼀般都是⽤这个版本(如果为0版本,所有的内容-1即可,如你算出next[5]=6,那么-1版本的next[5]就为5,反之亦然)~~其实上⾯的话总结就是⼀句话next[1]=0,j(模式串)数组的第⼀位下标为1,同时,前缀和后缀的最⼤匹配长度+1即为next数组的值,j所代表的的是序号的意思408反⼈类,⼀般数组第⼀位下标为1,关于书本上前⾯链表的学习⼤家就应该有⽬共睹了,书本上好多数组的第⼀位下标为了⽅便我们理解下标为1,想法这样我们更不好理解了,很反⼈类,所以这⾥给出next[1]=0,前缀和后缀的最⼤匹配长度+1的版本讲解前⾔以及问题引出我们先要知道,KMP算法是⽤于字符串匹配的~~例如:⼀个主串"abababcdef"我们想要知道在其中是否包括⼀个模式串"ababc"初代的解决⽅法是,朴素模式匹配算法,也就是我们主串和模式串对⽐,不同主串就往前移⼀位,从下⼀位开始再和模式串对⽐,每次只移动⼀位,这样会很慢,所以就有三位⼤神⼀起搞了个算法,也就是我们现在所称的KMP算法~~代码以及理解源码这⾥给出~~int Index_KMP(SString S,SString T,intt next[]){int i = 1,j = 1;//数组第⼀位下标为1while (i <= S.length && j <= T.length){if (j == 0 || S.ch[i] == T.ch[j]){//数组第⼀位下标为1,0的意思为数组第⼀位的前⾯,此时++1,则指向数组的第⼀位元素++i;++j; //继续⽐较后继字符}elsej = next[j]; //模式串向右移动到第⼏个下标,序号(第⼀位从1开始)}if (j > T.length)return i - T.length; //匹配成功elsereturn 0;}接下来就可以跟我来理解这个代码~~还不会做动图,这⾥就⼿画了~~以上是⼀般情况,那么如何理解j=next[1]=0的时候呢?是的,这就是代码的思路,那么这时我们就知道,核⼼就是要求next数组各个的值,对吧,⼀般也就是考我们next数组的值为多少~~next数组的求解这⾥先需要给出概念,串的前缀以及串的后缀~~串的前缀:包含第⼀个字符,且不包含最后⼀个字符的⼦串串的后缀:包含最后⼀个字符,且不包含第⼀个字符的⼦串当第j个字符匹配失败,由前1~j-1个字符组成的串记为S,则:next[j]=S的最长相等前后缀长度+1与此同时,next[1]=0如,模式串"ababaa"序号J123456模式串a b a b a anext[j]0当第六个字符串匹配失败,那么我们需要在前5个字符组成的串S"ababa"中找最长相等的前后缀长度为多少再+1~~如串S的前缀可以为:"a","ab","aba","abab",前缀只不包括最后⼀位都可串S的后缀可以为:"a","ba","aba","baba",后缀只不包括第⼀位都可所以这⾥最⼤匹配串就是"aba"长度为3,那么我们+1,取4序号J123456模式串a b a b a anext[j]04再⽐如,当第⼆个字符串匹配失败,由前1个字符组成的串S"a"中,我们知道前缀应当没有,后缀应当没有,所以最⼤匹配串应该为0,那么+1就是取1~~其实这⾥我们就能知道⼀个规律了,next[1]⼀定为0(源码所造成),next[2]⼀定为1(必定没有最⼤匹配串造成)~~序号J123456模式串a b a b a anext[j]014再再⽐如,第三个字符串匹配失败,由前两个字符组成的串S"ab"中找最长相等的前后缀长度,之后再+1~~前缀:"a"后缀:"b"所以所以这⾥最⼤匹配串也是没有的长度为0,那么我们+1,取1序号J123456模式串a b a b a anext[j]0114接下来你可以⾃⼰练练4和5的情况~~next[j]011234是不是很简单呢?⾄此,next数组的求法以及kmp代码的理解就ok了~~那么接下来,在了解以上之后,我们想⼀想KMP算法存在的问题~~KMP算法存在的问题如下主串:"abcababaa"模式串:"ababaa"例如这个问题我们很容易能求出next数组序号J123456模式串a b a b a anext[j]011234此时我们是第三个字符串匹配失败,所以我们的next[3]=1,也就是下次就是第⼀个字符"a"和主串中第三个字符"c"对⽐,可是我们刚开始的时候就已经知道模式串的第三个字符"a"和"c"不匹配,那么这⾥不就多了⼀步⽆意义的匹配了么?所以我们就会有kmp算法的⼀个优化了~~KMP算法的优化我们知道,模式串第三个字符"a"不和主串第三个字符"c"不匹配,next数组需要我们的next[3]=1,也就是下次就是第⼀个字符"a"和主串中第三个字符"c"对⽐,之后就是模式串第⼀个字符"a"不和"c"匹配,就是需要变为next[1]=0,那么我们要省去步骤,不就可以直接让next[3]=0么?序号J12345模式串a b a b anext[j]01123nextval[j]00那么怎么省去多余的步骤呢?这就是nextval数组的求法~~nextval的求法以及代码理解先贴出代码for (int j = 2;j <= T.length;j++){if (T.ch[next[j]] == T.ch[j])nextval[j] = nextval[next[j]];elsenextval[j] = next[j];}如序号J123456模式串a b a b a anext[j]011234nextval[j]0⾸先,第⼀次for循环,j=2,当前序号b的next[2]为1,即第⼀个序号所指向的字符a,a!=当前序号b,所以nextval[2]保持不变等于next[2]=1序号J123456模式串a b a b a anext[j]011234nextval[j]01第⼆次for循环,j=3,当前序号a的next[3]为1,即第⼀个序号所指向的字符a,a=当前序号a,所以nextval[3]等于nextval[1]=0序号J123456模式串a b a b a anext[j]011234nextval[j]010第三次for循环,j=4,当前序号b的next[4]为2,即第⼆个序号所指向的字符b,b=当前序号b,所以nextval[4]等于nextval[2]=1序号J123456模式串a b a b a anext[j]011234nextval[j]0101就是这样,你可以练练5和6,这⾥直接给出~~序号J123456模式串a b a b a anext[j]011234nextval[j]010104⾄此nextval数组的求法你也应该会了,那么考研要是考了,那么是不是就等于送分给你呢?⼩练习那么你试着来求⼀下这个模式串的next和nextval数组吧~~next[j]nextval[j]⼩练习的答案序号j12345模式串a a a a b next[j]01234 nextval[j]00004。
串的模式匹配算法
串的模式匹配算法字符串模式匹配是计算机科学中一种常用的算法。
它是一种检索字符串中特定模式的技术，可以用来在字符串中查找相应的模式，进而完成相应的任务。
字符串模式匹配的基本思想是，用一个模式串pattern去匹配另一个主串text，如果在text中找到和pattern完全匹配的子串，则该子串就是pattern的匹配串。
字符串模式匹配的过程就是在text中搜索所有可能的子串，然后比较它们是否和pattern完全匹配。
字符串模式匹配的算法有很多，其中著名的有暴力匹配算法、KMP算法、BM算法和Sunday算法等。
暴力匹配算法是最简单也是最常用的字符串模式匹配算法，其思想是从主串的某一位置开始，依次比较pattern中每一个字符，如果某个字符不匹配，则从主串的下一位置重新开始匹配。
KMP算法（Knuth-Morris-Pratt算法）是一种更为高效的字符串模式匹配算法，它的特点是利用了已匹配过的字符的信息，使搜索更加有效。
它的实现思想是，在pattern中先建立一个next数组，next数组的值代表pattern中每个字符前面的字符串的最大公共前缀和最大公共后缀的长度，这样可以在主串和模式串匹配失败时，利用next数组跳转到更有可能匹配成功的位置继续搜索，从而提高字符串模式匹配的效率。
BM算法（Boyer-Moore算法）也是一种高效的字符串模式匹配算法，它的实现思想是利用主串中每个字符最后出现的位置信息，以及模式串中每个字符最右出现的位置信息来跳转搜索，从而减少不必要的比较次数，提高搜索效率。
Sunday算法是一种简单而高效的字符串模式匹配算法，它的实现思想是，在主串中搜索时，每次从pattern的最右边开始比较，如果不匹配，则根据主串中下一个字符在pattern中出现的位置，将pattern整体向右移动相应位数，继续比较，这样可以减少不必要的比较次数，提高算法的效率。
字符串模式匹配算法的应用非常广泛，它可以用来查找文本中的关键字，检查一个字符串是否以另一个字符串开头或结尾，查找文本中的模式，查找拼写错误，检查字符串中是否包含特定的字符等。
kmp算法中模式字符串的nextval数组
在KMP 算法中，模式字符串的next 数组是一个关键部分。
next 数组的作用是存储模式字符串中每个字符的最长相等前缀后缀的长度。
这个数组有助于在匹配过程中跳过尽可能多的字符，从而提高匹配效率。
next 数组的计算方法如下：1. 初始化next 数组为长度为1 的数组，存储第一个字符的长度。
2. 遍历模式字符串的每个字符，对于每个字符，计算其最长前缀后缀的长度。
3. 更新next 数组，将当前字符的最长前缀后缀长度加1，并存储在next 数组中。
以下是一个简单的KMP 算法实现，其中包含next 数组的计算：```pythondef kmp_preprocess(pattern):next = [1] * len(pattern)j = 0for i in range(1, len(pattern)):while j > 0 and pattern[i] != pattern[j]:j = next[j - 1]if pattern[i] == pattern[j]:j += 1next[i] = jreturn nextdef kmp_search(text, pattern):next = kmp_preprocess(pattern)i = 0j = 0while i < len(text):while j > 0 and text[i] != pattern[j]:i += 1if text[i] == pattern[j]:i += 1j += 1if j == len(pattern):return i - jreturn -1text = "我国是一个伟大的国家"pattern = "国家"result = kmp_search(text, pattern)print(result)```在这个例子中，我们首先计算next 数组，然后使用next 数组进行文本匹配。
KMP算法的时间复杂度
KMP算法的时间复杂度KMP算法是一种字符串匹配算法，它可以在一个主串中高效地查找所有匹配某个模式串的位置。
在计算机科学中，算法的时间复杂度是衡量算法执行时间与输入规模之间关系的度量。
在本文中，我们将深入探讨KMP算法的时间复杂度。
KMP算法的时间复杂度可通过三个方面来分析：预处理阶段的时间复杂度、匹配阶段的时间复杂度以及总体时间复杂度。
1. 预处理阶段的时间复杂度在KMP算法中，要先对模式串进行预处理，生成部分匹配表（Partial Match Table），也称为最长公共前后缀表（Longest Proper Prefix which is also Sufix，简称为LPS表）。
这个过程的时间复杂度是O(m)，其中m是模式串的长度。
在生成部分匹配表的过程中，KMP算法利用了前缀与后缀的性质，通过动态规划的方式计算每个位置的最长匹配长度。
虽然这个过程需要遍历整个模式串，但是每次计算的操作都具有重叠子问题的性质，因此可以通过状态转移方程高效地计算出来。
2. 匹配阶段的时间复杂度在匹配阶段，KMP算法将主串与模式串进行逐个字符的比较，并利用已经生成的部分匹配表来决定下一次比较的位置。
这个过程的时间复杂度是O(n)，其中n是主串的长度。
在匹配过程中，KMP算法利用了部分匹配表的信息，根据当前位置的匹配长度来确定下一次比较的位置。
通过避免无效的比较，KMP 算法可以在最坏情况下实现线性的时间复杂度。
3. 总体时间复杂度KMP算法的总体时间复杂度是预处理阶段的时间复杂度与匹配阶段的时间复杂度之和。
即O(m) + O(n) = O(m + n)。
从总体时间复杂度可以看出，KMP算法的执行时间与主串和模式串的长度之和成正比。
相比于朴素的字符串匹配算法，KMP算法可以大大提高匹配的效率，尤其是在模式串较长的情况下。
总结：KMP算法的时间复杂度是O(m + n)，其中m是模式串的长度，n是主串的长度。
通过对模式串进行预处理并利用部分匹配表的信息，KMP算法可以高效地在主串中查找所有匹配模式串的位置。
kmp算法next计算方法
kmp算法next计算方法KMP算法是一种字符串匹配算法，它的核心在于利用已经部分匹配的信息来减少匹配的次数，从而提高匹配的效率。
在KMP算法中，next数组的计算是非常关键的一步，它可以帮助我们快速地找到匹配失败时，模式串应该向后移动的位置。
本文将详细介绍KMP算法中next数组的计算方法。
首先，我们先来了解一下next数组的含义。
在KMP算法中，next数组的含义是指在模式串中，每个位置上对应的最长公共前缀和最长公共后缀的长度。
这个定义可能有点抽象，我们通过一个具体的例子来说明。
假设模式串为"ABCDABD"，那么它的next数组为[-1, 0, 0, 0, 0, 1, 2]。
这里的-1表示第一个字符没有前缀和后缀，0表示第二个字符A的前缀和后缀的长度为0，以此类推，最后一个字符D的前缀和后缀的最大长度为2。
接下来，我们来介绍如何计算next数组。
计算next数组的方法有两种，一种是暴力匹配法，另一种是利用已知的next数组来计算。
暴力匹配法的思路是，对于模式串的每个位置i，都尝试找到它的最长公共前缀和最长公共后缀的长度。
这种方法的时间复杂度为O(n^2)，其中n为模式串的长度，显然效率不高。
而利用已知的next数组来计算的方法则更加高效。
具体步骤如下：1. 首先，我们将next数组初始化为-1，即next[0]=-1。
2. 然后，我们从模式串的第一个字符开始，依次计算每个位置上的next值。
3. 在计算位置i的next值时，我们首先假设位置i的前一个字符的next值已知，记为k，即next[i-1]=k。
4. 如果模式串的第k个字符和第i-1个字符相等，那么位置i的next值为k+1；否则，我们继续向前寻找更短的公共前缀和后缀，直到找到一个满足条件的k值或者k等于-1为止。
通过这种方法，我们可以高效地计算出整个模式串的next数组。
这样，在实际的匹配过程中，当发生匹配失败时，我们就可以根据next数组来快速地确定模式串应该向后移动的位置，从而提高匹配的效率。