KMP算法中next算法执行过程
数据结构教程李春葆课后答案第4章串
8. 采用顺序结构存储串，设计一个实现串通配符匹配的算法 pattern_index()，其中的 通配符只有‘？’ ，它可以和任一个字符匹配成功。例如，pattern_index("？re"，"there are") 返回的结果是 2。 解：采用 BF 算法的穷举法的思路，只需要增加对‘?’字符的处理功能。对应的算法 如下：
void maxsubstr(SqString s,SqString &t) { int maxi=0,maxlen=0,len,i,j,k; i=0; while (i<s.length) //从下标为 i 的字符开始 { j=i+1; //从 i 的下一个位置开始找重复子串 while (j<s.length) { if (s.data[i]==s.data[j]) //找一个子串,其起始下标为 i,长度为 len { len=1; for(k=1;s.data[i+k]==s.data[j+k];k++) len++; if (len>maxlen) //将较大长度者赋给 maxi 与 maxlen { maxi=i; maxlen=len; } j+=len; } else j++; } i++; //继续扫描第 i 字符之后的字符 } t.length=maxlen; //将最长重复子串赋给 t for (i=0;i<maxlen;i++) t.data[i]=s.data[maxi+i]; }
SqString CommChar(SqString s1,SqString s2) { SqString s3; int i,j,k=0; for (i=0;i<s1.length;i++) { for (j=0;j<s2.length;j++) if (s2.data[j]==s1.data[i]) break; if (j<s2.length) //s1.data[i]是公共字符 { s3.data[k]=s1.data[i]; k++; } } s3.length=k; return s3; }
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。
KMP算法详解
KMP算法详解KMP 算法详解KMP 算法是⼀个⼗分⾼效的字符串查找算法，⽬的是在⼀个字符串 s 中，查询 s 是否包含⼦字符串 p，若包含，则返回 p 在 s 中起点的下标。
KMP 算法全称为 Knuth-Morris-Pratt 算法，由 Knuth 和 Pratt 在1974年构思，同年 Morris 也独⽴地设计出该算法，最终由三⼈于1977年联合发表。
举⼀个简单的例⼦，在字符串 s = ababcabababca 中查找⼦字符串 p = abababca，如果暴⼒查找，我们会遍历 s 中的每⼀个字符，若 s[i] = p[0]，则向后查询p.length() 位是否都相等。
这种朴素的暴⼒的算法复杂度为O(m×n)，其中m和n分别是 p 和 s 的长度。
KMP 算法可以⽅便地简化这⼀查询的时间复杂度，达到O(m+n)。
1. PMT 序列PMT 序列是 KMP 算法的核⼼，即 Partial Match Table（部分匹配表）。
举个例⼦：char a b a b a b c aindex01234567PMT00123401PMT 的值是字符串的前缀集合与后缀集合的交集中最长元素的长度。
PMT[0] = 0: 字符串 a 既没有前缀，也没有后缀；PMT[1] = 0: 字符串 ab 前缀集合为 {a}，后缀集合为 {b}，没有交集；PMT[2] = 1: 字符串 aba 前缀集合为 {a, ab}，后缀集合为 {ba, a}，交集为 {a}，交集元素的最长长度为1；PMT[3] = 2: 字符串 abab 前缀集合为 {a, ab, aba}，后缀集合为 {bab, ab, b}，交集为 {ab}，交集元素的最长长度为2；…… 以此类推。
2. 算法主体现在我们已经知道了 PMT 序列的含义，那么假设在 PMT 序列已经给定的情况下，如何加速字符串匹配算法？tar 存储 s 的下标，从 0 开始，若 tar > s.length() - 1，代表匹配失败；pos 存储 p 的下标，从 0 开始，若 s[tar] != p[pos]，则 pos ⾛到下⼀个可能匹配的位置。
数据结构串的next数组
数据结构串的next数组数据结构串的next数组是在字符串匹配算法中常用的一种辅助数组。
它主要用于在模式串与目标串进行匹配时，确定匹配失败时模式串应该移动的位置。
next数组的长度与模式串的长度相同，具体的计算方式如下：1. 首先，next[0]被定义为-1，表示当第一个字符与目标串不匹配时，模式串应该移动到下一个位置。
2. 然后，依次计算next[i]，其中i的范围是1到模式串长度减1。
a. 假设已经计算出了next[0]到next[i-1]的值。
b. 针对下标i，首先将next[i]初始化为-1。
c. 然后，从下标0开始与下标i-1进行比较，找到最长的前缀和后缀匹配子串的长度k。
d. 如果存在这样的子串，则将next[i]设置为k。
3. 最后得到的next数组即为模式串中每个位置匹配失败时应该向前移动的位置。
以模式串"ababc"为例，计算next数组的过程如下：1. next[0] = -1。
2. 对于next[1]，比较模式串的第0个位置和第1个位置的字符"a"和"b"，发现不匹配，所以next[1]仍为-1。
3. 对于next[2]，比较模式串的第0个位置和第2个位置的字符"a"和"a"，发现匹配，所以next[2]为0。
4. 对于next[3]，比较模式串的第0个位置和第3个位置的字符"a"和"b"，发现不匹配，继续比较第1个位置和倒数第2个位置的字符"b"和"a"，发现不匹配，所以next[3]仍为-1。
5. 对于next[4]，比较模式串的第0个位置和第4个位置的字符"a"和"c"，发现不匹配，继续比较第1个位置和倒数第2个位置的字符"b"和"b"，发现匹配，然后比较第2个位置和倒数第3个位置的字符"a"和"a"，发现匹配，所以next[4]为2。
abaabaab的next数组
abaabaab的next数组是指在字符串abaabaab中，每个前缀的最长相等真前后缀的长度数组。
这个数组在字符串匹配算法中非常重要，它可以帮助我们更快地进行字符串匹配，提高算法的效率。
为了更好地理解abaabaab的next数组，我们首先需要了解字符串匹配算法中的KMP算法。
KMP算法是一种经典的字符串匹配算法，它利用了字符串本身的信息，在匹配过程中尽量减少回溯，以达到提高匹配效率的目的。
在KMP算法中，我们需要先构建出模式串的next数组。
这个next数组其实是一个关于模式串的自身匹配情况的数组，它的定义如下：1. 对于模式串P中的每一个位置i，next[i]的值代表P[0]到P[i]这个子串的最长相等真前后缀的长度。
2. 如果模式串P的长度为n，则next数组的长度也为n。
以abaabaab为例，它的next数组为[0, 0, 1, 1, 2, 3, 4, 5]。
下面我们来详细解释一下这个数组是如何得出的。
1. 我们先来求出每个位置的最长相等真前后缀的长度。
位置0：a，这个位置是一个单字符，自身没有真前后缀，所以长度为0。
位置1：ab，这个位置没有真前后缀，长度为0。
位置2：aba，这个位置的最长相等真前后缀为a，长度为1。
位置3：abaa，这个位置的最长相等真前后缀为a，长度为1。
位置4：abaab，这个位置的最长相等真前后缀为aba，长度为3。
位置5：abaaba，这个位置的最长相等真前后缀为abaab，长度为4。
位置6：abaabaa，这个位置的最长相等真前后缀为abaaba，长度为5。
位置7：abaabaab，这个位置的最长相等真前后缀为abaabaa，长度为5。
经过上面的计算，我们得到了abaabaab的next数组为[0, 0, 1, 1, 2, 3, 4, 5]。
2. 接下来我们来讨论一下如何利用这个next数组来进行字符串匹配。
假设我们现在有一个文本串T和一个模式串P，我们希望在文本串T中找到模式串P的位置。
KMP模式匹配算法
KMP模式匹配算法KMP算法是一种字符串匹配算法，用于在一个主串中查找一个模式串的出现位置。
该算法的核心思想是通过预处理模式串，构建一个部分匹配表，从而在匹配过程中尽量减少不必要的比较。
KMP算法的实现步骤如下：1.构建部分匹配表部分匹配表是一个数组，记录了模式串中每个位置的最长相等前后缀长度。
从模式串的第二个字符开始，依次计算每个位置的最长相等前后缀长度。
具体算法如下：-初始化部分匹配表的第一个位置为0，第二个位置为1- 从第三个位置开始，假设当前位置为i，则先找到i - 1位置的最长相等前后缀长度记为len，然后比较模式串中i位置的字符和模式串中len位置的字符是否相等。
- 如果相等，则i位置的最长相等前后缀长度为len + 1- 如果不相等，则继续判断len的最长相等前后缀长度，直到len为0或者找到相等的字符为止。
2.开始匹配在主串中从前往后依次查找模式串的出现位置。
设置两个指针i和j，分别指向主串和模式串的当前位置。
具体算法如下：-当主串和模式串的当前字符相等时，继续比较下一个字符，即i和j分别向后移动一个位置。
-当主串和模式串的当前字符不相等时，根据部分匹配表确定模式串指针j的下一个位置，即找到模式串中与主串当前字符相等的位置。
如果找到了相等的位置，则将j移动到相等位置的下一个位置，即j=部分匹配表[j]；如果没有找到相等的位置，则将i移动到下一个位置，即i=i+13.检查匹配结果如果模式串指针j移动到了模式串的末尾，则说明匹配成功，返回主串中模式串的起始位置；如果主串指针i移动到了主串的末尾，则说明匹配失败，没有找到模式串。
KMP算法的时间复杂度为O(m+n)，其中m为主串的长度，n为模式串的长度。
通过预处理模式串，KMP算法避免了在匹配过程中重复比较已经匹配过的字符，提高了匹配的效率。
总结：KMP算法通过构建部分匹配表，实现了在字符串匹配过程中快速定位模式串的位置，减少了不必要的比较操作。
数据结构教学中KMP算法解析
数据结构教学中KMP算法解析摘要：模式匹配是字符串的基本运算之一，也是数据结构教学中的难点之一。
分析了模式匹配KMP算法以及算法中next函数的含义，给出了next函数的两种实现方法，有助于在教学实践中帮助学生更好地理解该算法。
关键词：数据结构；模式匹配；KMP算法0引言模式匹配（Patten Matching）是许多计算机应用领域的基础问题，在数据结构中模式匹配是字符串的基本运算之一。
字符串模式匹配指的是，找出特定的模式串在一个较长的字符串中出现的位置。
有两个字符串S和T，字符串S称为目标串，字符串T称为模式串，要求找出模式T在S中的首次出现的位置。
一旦模式T在目标S中找到，就称发生一次匹配。
有些应用可能会要求找出所有的匹配位置<sup>[1]</sup>。
例如，目标串S= 'Shanghai'，模式串T= 'gha'，则匹配结果为4。
模式匹配的典型算法包括朴素匹配算法、KMP算法和BM算法等，其中KMP算法是效率较高且经典的模式匹配算法之一<sup>[2]</sup>。
在数据结构教学中，由于KMP算法较难理解，课堂讲授往往很难取得好的效果。
本文通过对传统的朴素匹配算法与KMP算法的比较，分析next函数的含义以及实现方法，来帮助理解KMP算法。
1朴素匹配算法在朴素匹配算法中，S和T分别为目标串和模式串，变量i和j 为两个静态指针，分别表示S和T中当前正待比较的字符位置。
算法的基本思想是：第1趟匹配：从S的第1个字符（序号为0）起和T的第一个字符比较之，如果相等，则继续逐个比较后续字符（i++；j++），否则开始下一趟匹配。
新的一趟匹配：i的初值为上一趟的初值+1 ，j的初值为1，如果比较结果相等，则继续逐个比较后续字符，否则开始下一趟匹配。
依次类推，直至某一趟匹配中，T的每个字符依次和S中的一个连续的字符序列相等，则称匹配成功，否则称匹配不成功。
KMP算法中next数组的理解与算法的实现（java语言）
KMP算法中next数组的理解与算法的实现（java语⾔）KMP 算法我们有写好的函数帮我们计算 Next 数组的值和 Nextval 数组的值，但是如果是考试，那就只能⾃⼰来⼿算这两个数组了，这⾥分享⼀下我的计算⽅法吧。
计算前缀 Next[i] 的值:我们令 next[0] = -1 。
从 next[1] 开始，每求⼀个字符的 next 值，就看它前⾯是否有⼀个最长的"字符串"和从第⼀个字符开始的"字符串"相等(需要注意的是，这2个"字符串"不能是同⼀个"字符串")。
如果⼀个都没有，这个字符的 next 值就是0；如果有，就看它有多长，这个字符的next 值就是它的长度。
计算修正后的 Nextval[i] 值:我们令 nextval[0] = -1。
从 nextval[1] 开始，如果某位(字符)与它 next 值指向的位(字符)相同，则该位的 nextval 值就是指向位的 nextval 值(nextval[i] = nextval[ next[i] ])；如果不同，则该位的 nextval 值就是它⾃⼰的 next 值(nextvalue[i] = next[i])。
举个例⼦:计算前缀 Next[i] 的值:next[0] = -1;定值。
next[1] = 0;s[1]前⾯没有重复⼦串。
next[2] = 0;s[2]前⾯没有重复⼦串。
next[3] = 0;s[3]前⾯没有重复⼦串。
next[4] = 1;s[4]前⾯有重复⼦串s[0] = 'a'和s[3] = 'a'。
next[5] = 2;s[5]前⾯有重复⼦串s[01] = 'ab'和s[34] = 'ab'。
next[6] = 3;s[6]前⾯有重复⼦串s[012] = 'abc'和s[345] = 'abc'。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第10轮循环，i=6，j=0： void get_next(SString &T, int &next[] ) {
while (6 < T[0]) { if (j = 0 || T[6] == T[0]) { i=i+1=7; j=j+1=1; next[7] = 1; } } } // get_next
第2轮循环，i=2，j=1： void get_next(SString &T, int &next[] ) {
while (2 < T[0]) { j!=0 || T[2]!=T[1]， 不满足if，所以执行： else j = next[1]=0; } } // get_next
i = 1; next[1] = 0; j = 0; while (i < T[0]) { if (j = 0 || T[i] == T[j]) {++i; ++j; next[i] = j; } else j = next[j]; } } // get_next
位序 T串
1
2
a
0
b
1
a
1
a
2
b
2
c
a
b
c
Next值
例题：求T串abaabcabcnext函数值的递推过程:
原函数： void get_next(SString &T, int &next[] ) {
// 求模式串T的next函数值并 存入数组next
第7轮循环，i=5，j=2： void get_next(SString &T, int &next[] ) {
j
i
4 5 6 7 8 9
第7轮执行 完毕结果：
位序 T串
1
2
3
a
0
b
1
a
1
a
2
b
2c3Fra bibliotekab
c
Next值
例题：求T串abaabcabcnext函数值的递推过程:
原函数： void get_next(SString &T, int &next[] ) {
// 求模式串T的next函数值并 存入数组next
第5轮循环，i=4，j=2： void get_next(SString &T, int &next[] ) {
while (4 < T[0]) { j!=0 || T[4]!=T[2]， 不满足if，所以执行： else j = next[2]=1; } } // get_next
i = 1; next[1] = 0; j = 0; while (i < T[0]) { if (j = 0 || T[i] == T[j]) {++i; ++j; next[i] = j; } else j = next[j]; } } // get_next
j
i
1 2 3 4 5 6 7 8 9
第2轮执行 完毕结果：
位序 T串
a
0
b
1
a
a
b
c
a
b
c
Next值
例题：求T串abaabcabcnext函数值的递推过程:
原函数： void get_next(SString &T, int &next[] ) {
// 求模式串T的next函数值并 存入数组next
while (5 < T[0]) { if (j = 0 || T[5] == T[2]) { i=i+1=6; j=j+1=3; next[6] = 3; } } } // get_next
i = 1; next[1] = 0; j = 0; while (i < T[0]) { if (j = 0 || T[i] == T[j]) {++i; ++j; next[i] = j; } else j = next[j]; } } // get_next
这实际上也是一个匹配的过程。 不同在于：主串和模式串是同一个串。
例题：求T串abaabcabcnext函数值的递推过程:
原函数： void get_next(SString &T, int &next[] ) {
// 求模式串T的next函数值并 存入数组next
i = 1; next[1] = 0; j = 0; while (i < T[0]) { if (j = 0 || T[i] == T[j]) {++i; ++j; next[i] = j; } else j = next[j]; } } // get_next
j
i
3 4 5 6 7 8 9
第4轮执行 完毕结果：
位序 T串
1
2
a
0
b
1
a
1
a
2
b
c
a
b
c
Next值
例题：求T串abaabcabcnext函数值的递推过程:
原函数： void get_next(SString &T, int &next[] ) {
// 求模式串T的next函数值并 存入数组next
第8轮循环，i=6，j=3： void get_next(SString &T, int &next[] ) {
while (6 < T[0]) { j!=0 || T[6]!=T[3]， 不满足if，所以执行： else j = next[3]=1; } } // get_next
i = 1; next[1] = 0; j = 0; while (i < T[0]) { if (j = 0 || T[i] == T[j]) {++i; ++j; next[i] = j; } else j = next[j]; } } // get_next
i = 1; next[1] = 0; j = 0; while (i < T[0]) { if (j = 0 || T[i] == T[j]) {++i; ++j; next[i] = j; } else j = next[j]; } } // get_next
j
i
2 3 4 5 6 7 8 9
第8轮执行 完毕结果：
位序 T串
1
a
0
b
1
a
1
a
2
b
2
c
3
a
b
c
Next值
例题：求T串abaabcabcnext函数值的递推过程:
原函数： void get_next(SString &T, int &next[] ) {
// 求模式串T的next函数值并 存入数组next
第1轮循环，i=1，j=0： void get_next(SString &T, int &next[] ) { i = 1; next[1] = 0; j = 0; while (1 < T[0]) { if (j = 0 || T[1] == T[0]) { i=i+1=2; j=j+1=1; next[2] = 1; } } } // get_next
i = 1; next[1] = 0; j = 0; while (i < T[0]) { if (j = 0 || T[i] == T[j]) {++i; ++j; next[i] = j; } else j = next[j]; } } // get_next
j
i
3 4 5 6 7 8 9
第6轮执行 完毕结果：
j
i
2 3 4 5 6 7 8 9
第5轮执行 完毕结果：
位序 T串
1
a
0
b
1
a
1
a
2
b
c
a
b
c
Next值
例题：求T串abaabcabcnext函数值的递推过程:
原函数： void get_next(SString &T, int &next[] ) {
// 求模式串T的next函数值并 存入数组next
第6轮循环，i=4，j=1： void get_next(SString &T, int &next[] ) {
while (4 < T[0]) { if (j = 0 || T[4] == T[1]) { i=i+1=5; j=j+1=2; next[5] = 2; } } } // get_next
位序 T串
1
a
0
b
1
a
1
a
b
c
a
b
c
Next值
例题：求T串abaabcabcnext函数值的递推过程:
原函数： void get_next(SString &T, int &next[] ) {
// 求模式串T的next函数值并 存入数组next
第4轮循环，i=3，j=1： void get_next(SString &T, int &next[] ) {
i = 1; next[1] = 0; j = 0; while (i < T[0]) { if (j = 0 || T[i] == T[j]) {++i; ++j; next[i] = j; } else j = next[j]; } } // get_next