KMP算法中next算法执行过程

合集下载

数据结构教程李春葆课后答案第4章串

数据结构教程李春葆课后答案第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数组)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 &lt;= S.length &amp;&amp; j &lt;= T.length){if (j == 0 || S.ch[i] == T.ch[j]){//数组第⼀位下标为1,0的意思为数组第⼀位的前⾯,此时++1,则指向数组的第⼀位元素++i;++j; //继续⽐较后继字符}elsej = next[j]; //模式串向右移动到第⼏个下标,序号(第⼀位从1开始)}if (j &gt; 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 &lt;= 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 算法详解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数组是在字符串匹配算法中常用的一种辅助数组。

它主要用于在模式串与目标串进行匹配时,确定匹配失败时模式串应该移动的位置。

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的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算法是一种字符串匹配算法,用于在一个主串中查找一个模式串的出现位置。

该算法的核心思想是通过预处理模式串,构建一个部分匹配表,从而在匹配过程中尽量减少不必要的比较。

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算法解析摘要:模式匹配是字符串的基本运算之一,也是数据结构教学中的难点之一。

分析了模式匹配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数组的理解与算法的实现(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'。

kmp next算法

kmp next算法

kmp next算法KMP算法(Knuth-Morris-Pratt Algorithm)是一种字符串匹配算法,它的核心思想是利用已经得到的匹配结果,尽量减少字符的比较次数,提高匹配效率。

本文将详细介绍KMP算法的原理、实现方法以及应用场景。

一、KMP算法的原理KMP算法的核心是构建next数组,用于指导匹配过程中的回溯操作。

next数组的定义是:对于模式串中的每个字符,记录它前面的子串中相同前缀和后缀的最大长度。

next数组的长度等于模式串的长度。

具体来说,KMP算法的匹配过程如下:1. 初始化主串指针i和模式串指针j为0。

2. 逐个比较主串和模式串对应位置的字符:- 若主串和模式串的字符相等,i和j同时后移一位。

- 若主串和模式串的字符不相等,根据next数组的值,将模式串指针j回溯到合适的位置,继续匹配。

二、KMP算法的实现KMP算法的实现可以分为两个步骤:构建next数组和利用next数组进行匹配。

1. 构建next数组:- 首先,next[0]赋值为-1,next[1]赋值为0。

- 然后,从第2个位置开始依次计算next[i],根据前一个位置的next值和模式串的字符进行判断:- 若前一个位置的next值为-1或模式串的字符与前一个位置的字符相等,则next[i] = next[i-1] + 1。

- 若前一个位置的next值不为-1且模式串的字符与前一个位置的字符不相等,则通过next数组的回溯操作,将模式串指针j回溯到合适的位置,继续判断。

2. 利用next数组进行匹配:- 在匹配过程中,主串指针i和模式串指针j会同时后移:- 若主串和模式串的字符相等,i和j同时后移一位。

- 若主串和模式串的字符不相等,则根据next数组的值,将模式串指针j回溯到合适的位置,继续匹配。

三、KMP算法的应用场景KMP算法在字符串匹配中有广泛的应用,特别是在大规模文本中的模式匹配问题上具有明显的优势。

以下是KMP算法的几个应用场景:1. 子串匹配:判断一个字符串是否是另一个字符串的子串。

2016年下半年软件设计师考试下午真题(试题及参考答案)

2016年下半年软件设计师考试下午真题(试题及参考答案)

2016年下半年软件设计师考试下午真题(参考答案)试题部分1.阅读下列说明,回答问题1至问题4,将解答填入答题纸的对应栏内。

【说明】某证券交易所为了方便提供证券交易服务,欲开发一证券交易平台,该平台的主要功能如下:(1)开户。

根据客户服务助理提交的开户信息,进行开户,并将客户信息存入客户记录中,账户信息(余额等)存入账户记录中;(2)存款。

客户可以向其账户中存款,根据存款金额修改账户余额;(3(4(5所示的0【问题1【问题2【问题3【问题42.【说明】(1(2经理、业务员。

(3)客房信息包括客房号(如1301、1302等)、客房类型、收费标准、入住状态(已入住/未入住),其中客房号唯一标识客房关系中的一个元组,不同客房类型具有不同的收费标准。

(4)客户信息包括客户号、单位名称、联系人、联系电话、联系地址,其中客户号唯一标识客户关系中的一个元组。

(5)客户预订客房时,需要填写预订申请。

预订申请信息包括申请号、客户号、入住时间、入住天数、客房类型、客房数量,其中,一个申请号唯一标识预订申请中的一个元组;一位客户可以有多个预订申请,但一个预订申请对应唯一的一位客户。

(6)当客户入住时,业务员根据客户的预订申请负责安排入住客房事宜。

安排信息包括客房号、姓名、性别、【概念模型设计】根据需求阶段收集的信息,设计的实体联系图如图2-1所示。

【关系模式设计】部门(部门号,部门名称,经理,电话)员工(员工号,(a),姓名,岗位,电话,工资)客户((b),联系人,联系电话,联系地址)客房(客房号,客房类型,收费标准,入住状态)预订申请((c),入住时间,天数,客房类型,客房数量)安排(申请号,客房号,姓名,性别,(c),天数,电话,业务员)【问题1】(4分)根据问题描述,补充四个联系,完善图2-1,的实体联系图。

联系名可用联系1、联系2、联系3和联系4代替,【问题2(1(2【问题33.【说明】(1(2(31234.自动售货机推出饮料;5.自动售货机返回找零。

kmp算法next数组构造过程

kmp算法next数组构造过程

kmp算法next数组构造过程
KMP算法的核心部分就是构造next数组,它的作用是在模式
串与目标串不匹配时,快速确定模式串需要移动的位置,从而避免不必要的比较操作。

下面是KMP算法中next数组的构造过程:
1. 首先,创建一个长度与模式串相同的数组next[],用于存储
每个位置的next值。

2. 将next[0]初始化为-1,next[1]初始化为0,这是因为当模式
串只有一个字符时,无法进行移动,所以next[1]为0。

3. 从位置2开始,使用一个指针i遍历整个模式串。

在遍历的
过程中,不断更新next[i]的值。

4. 对于每个位置的next[i],需要判断模式串中位置i之前的子
串的前缀与后缀是否存在重复。

具体操作如下:
- 首先,将next[i-1]的值赋给一个临时变量j,并递归比较j
与i-1位置的字符是否相等。

如果相等,则next[i]的值为j+1;如果不相等,则将next[j]的值再赋给j,重新进行比较。

- 重复上述过程,直到找到一个相等的前缀和后缀,或者不
能再递归比较为止。

5. 当指针i遍历完整个模式串后,next数组的构造过程完成。

这个构造过程的时间复杂度为O(m),其中m是模式串的长度。

通过构造好的next数组,可以快速确定模式串的移动位置,
从而提高匹配效率。

KMP算法的next函数求解和分析过程

KMP算法的next函数求解和分析过程

KMP算法的next函数求解和分析过程转⾃:/wang0606120221/article/details/7402688假设KMP算法中的模式串为P,主串为S,那么该算法中的核⼼是计算出模式串的P的next函数。

KMP算法是在已知的模式串的next函数值的基础上进⾏匹配的。

由于本次只讨论next的求值过程,因此KMP算法的数学推理过程这⾥不再讲解。

从KMP算法的数学推理可知,此next函数只取决与模式匹配串⾃⾝的特点和主串没有任何关系,此函数默认认为next[1]=0,由于next[j]=k表⽰的意义是当模式串和主串的第j个字符不匹配时,那么接下来和主串的第j个字符匹配的字符是模式串的第k个字符。

因此,next[1]=0表⽰当主串的当前字符和模式串的第1个字符不匹配,接下来需要⽤模式串的第0个字符和主串的当前字符匹配,由于模式串下标是从1开始的,所以不可能存在第0个字符,即接下的匹配动作是主串和模式串同时向右移动⼀位,继续模式匹配。

例如:主串:a c a b a a b a a b n a c模式串:a b a a b主串:a c a b a a b a a b n a c模式串: a b a a b主串:a c a b a a b a a b n a c模式串: a b a a b此时,主串和模式串不匹配,⽽next[1]=0,因此,模式串的第0个字符和主串的第2个字符⽐较,⽽模式串没有第0个字符,此时可以把第0个字符理解为空字符,即模式串向右移动⼀位,主串再继续喝模式串匹配,⽽此时的主串的当前字符是第3个字符,整体来看是当主串和模式串的第1个字符不匹配时,主串和模式串同时右移⼀位,然后继续匹配。

接下来讲解⼀般情况下的next函数值求解过程。

设next[j]=k,根据KMP算法的模式串的特点可知,‘p1p2......pk-1’=‘pj-k+1......pj-1’,其中k必须满⾜1<k<j,并且不可能存在k‘>k满⾜上⾯等式。

K M P 算 法 详 解

K M P 算 法 详 解

KMP算法详解(转)此前一天,一位MS的朋友邀我一起去与他讨论快速排序,红黑树,字典树,B树、后缀树,包括KMP算法,唯独在讲解KMP算法的时候,言语磕磕碰碰,我想,原因有二:1、博客内的东西不常回顾,忘了不少;2、便是我对KMP算法的理解还不够彻底,自不用说讲解自如,运用自如了。

所以,特再写本篇文章。

由于此前,个人已经写过关于KMP算法的两篇文章,所以,本文名为:KMP算法之总结篇。

本文分为如下六个部分:第一部分、再次回顾普通的BF算法与KMP算法各自的时间复杂度,并两相对照各自的匹配原理;第二部分、通过我此前第二篇文章的引用,用图从头到尾详细阐述KMP算法中的next数组求法,并运用求得的next数组写出KMP算法的源码;第三部分、KMP算法的两种实现,代码实现一是根据本人关于KMP算法的第二篇文章所写,代码实现二是根据本人的关于KMP算法的第一篇文章所写;第四部分、测试,分别对第三部分的两种实现中next数组的求法进行测试,挖掘其区别之所在;第五部分、KMP完整准确源码,给出KMP算法的准确的完整源码;第六步份、一眼看出字符串的next数组各值,通过几个例子,让读者能根据字符串本身一眼判断出其next数组各值。

力求让此文彻底让读者洞穿此KMP算法,所有原理,来龙去脉,让读者搞个通通透透(注意,本文中第二部分及第三部分的代码实现一的字符串下标i从0开始计算,其它部分如第三部分的代码实现二,第五部分,和第六部分的字符串下标i 皆是从1开始的)。

第一部分、KMP算法初解1、普通字符串匹配BF算法与KMP算法的时间复杂度比较KMP算法是一种线性时间复杂的字符串匹配算法,它是对BF算法(Brute-Force,最基本的字符串匹配算法的)改进。

对于给的原始串S 和模式串P,需要从字符串S中找到字符串P出现的位置的索引。

BF算法的时间复杂度O(strlen(S) * strlen(T)),空间复杂度O(1)。

下半年软件设计师考试下午真题试题及参考答案

下半年软件设计师考试下午真题试题及参考答案

20XX年下半年软件设计师考试下午真题(参考答案)试题部分1.阅读下列说明,回答问题1至问题4,将解答填入答题纸的对应栏内。

【说明】某证券交易所为了方便提供证券交易服务,欲开发一证券交易平台,该平台的主要功能如下:(1)开户。

根据客户服务助理提交的开户信息,进行开户,并将客户信息存入客户记录中,账户信息(余额等)存入账户记录中;(2)存款。

客户可以向其账户中存款,根据存款金额修改账户余额;(3)取款。

客户可以从其账户中取款,根据取款金额修改账户余额;(4)证券交易。

客户和经纪人均可以进行证券交易(客户通过在线方式,经纪人通过电话),将交易信息存入交易记录中;(5 )检查交易。

平台从交易记录中读取交易信息,将交易明细返回给客户。

现采用结构化方法对该证券交易平台进行分析与设计,获得如图1-1所示的上下文数据流图和图1-2所示的0层数据流图。

^1-1上下文数据流图^1-2 0层数据流圉【问题1】(3分)使用说明中的词语,给出图 【问题21( 3分)使用说明中的词语,给出图 【问题31 (4分)根据说明和图中的术语,补充图 1-2中缺失的数据流及其起点和终点。

【问题41 ( 5分)实际的证券交易通常是在证券交易中心完成的,因此,该平台的“证券交易” 功能需将交易信息传递给证券交易中心。

针对这个功能需求,需要对图1-1和图1-2进行哪些修改,请用200字以内的文字加以说明。

2.阅读下列说明,回答问题 1至问题3,将解答填入答题纸的对应栏内。

【说明1某宾馆为了有效地管理客房资源, 满足不同客户需求,拟构建一套宾馆信息管理系统,以方便宾馆管理及客房预订等业务活动。

【需求分析结果1该系统的部分功能及初步需求分析的结果如下:(1) 宾馆有多个部门,部门信息包括部门号、部门名称、电话、经理。

每个部门可以有多 名员工,每名员工只属于一个部门;每个部门只有一名经理,负责管理本部门。

(2)员工信息包括员工号、姓名、岗位、电话、工资,其中,员工号唯一标识员工关系中1-1中的实体E1-E3的名称。

《KMP 字符串模式匹配算法》教学课例

《KMP 字符串模式匹配算法》教学课例

《KMP字符串模式匹配算法》教学课例程玉胜安庆师范学院计算机与信息学院KMP字符串模式匹配是数据结构课程中一个重要的知识点,也是一个难点(学过KMP 算法的同学100%认为:KMP是数据结构课程中最难的部分)。

为了消除他们对KMP算法学习的恐惧心理,激发他们的学习兴趣,调动其积极性,显得尤为重要。

基于以上,我们根据学生的认知特点和接受水平,对教材内容进行了重新构建,并按照数据结构中“时间复杂度”概念,增加了不同模式匹配算法的运行时间,动态逼真的显示了算法的“时间”性能,获得了较好的教学效果。

一、教学目标知识目标:让学生了解KMP算法应用的普遍性。

如:在目前众多的文字处理软件中得到广泛应用,如Microsoft Word中的“查找”或“替换”操作。

而这种操作实现的机制,同学们特别是计算机专业的学生很少去想过。

能力目标:要求学生体验一个完整的抽象数据类型(ADT)的实现方法和过程,并学会判断、计算算法优劣的方法。

价值目标:消除恐怖的学习心态,让学生感悟数据结构算法实际应用价值,从而激发学习的兴趣,形成积极主动式学习的态度。

二、教材分析使用教材是清华大学严蔚敏教授并由清华大学出版社出版的《数据结构(C语言版)》,该教材难度较大,其实验方法特别是ADT方法在教材中介绍较少,而且KMP算法更是从理论分析的角度介绍了匹配算法和next的计算,自学难度很大;虽然该节知识点属于“**(表示难度较大,可以不讲)”,但是其又是考研的一个热点,所以我们又不得不讲。

三、教学重点、难点教学重点:KMP算法中的next和改进的nextval计算教学难点:KMP算法中如何计算next值四、教具准备卡片:多个字符串,字符串指针强力磁吸:6个五、互动式教学过程教学内容教师活动学生活动目标状态创设情境引入课题目前的众多软件中,“查找”、“替换”等操作实现方法,要求学生举例。

给出一篇word文档完成在上述文档中从当前位置向后查找“计算机”或者向前查找“计算机”字符串的方法。

kmp算法中模式串的next数组值

kmp算法中模式串的next数组值

kmp算法中模式串的next数组值
模式串的next数组值是一个与模式串长度相同的数组,用于
指示当匹配失败时应该回退的位置。

计算next数组的方法如下:
1. 首先将next[0]赋值为-1,表示第一个位置没有可回退的位置。

2. 然后,从第二个位置开始,依次计算next[i]的值。

3. 假设已经计算出next[i-1]的值,即前i-1个字符的最长公共
前后缀的长度为next[i-1]。

4. 如果模式串的第i个字符与前i-1个字符的最长公共前后缀
的下一个字符相等,则next[i] = next[i-1] + 1。

5. 如果模式串的第i个字符与前i-1个字符的最长公共前后缀
的下一个字符不相等,则需要不断回退,直到找到一个位置j,使得模式串的前j个字符与前i-1个字符的前j个字符相等。

6. 因此,需要将next[i-1]的值作为起点,依次向左比较,找到
这个位置j。

7. 如果找到了这个位置j,则next[i] = next[j] + 1,表示下一次
匹配失败时应该回退到这个位置。

8. 如果找不到这个位置j,说明前i个字符没有任何公共前后缀,此时next[i] = 0。

根据上述方法,可以依次计算出模式串的next数组的值。

第二章 线性表 答案

第二章 线性表 答案

数据结构与算法上机作业第二章线性表一、选择题1、若长度为n的线性表采用顺序存储结构,在其第i个位置插入一个新的元素算法的时间复杂度为 C 。

A. O(log2n)B. O(1)C. O(n)D. O(n2)2、以下关于线性表的说法中,不正确的是 C 。

A. 线性表中的数据元素可以是数字、字符、结构等不同类型B. 线性表中包含的数据元素个数不是任意的C. 线性表中的每一个结点都有且只有一个直接前驱和直接后继D. 存在这样的线性表:表中各结点都没有直接前驱和直接后继3、在有n个结点的顺序表上做插入、删除结点运算的时间复杂度为 B 。

A. O(1)B. O(n)C. O(n2)D. O(log2n)4、等概率情况下,在有n个结点的顺序表上做插入结点操作,需平均移动的结点数目为C 。

提示:插入的位置有n+1个,移动总数为:1+2+3+……+nA. nB. (n-1)/2C. n/2D. (n+1)/25、在一个长度为n的顺序存储的线性表中查找值为x的元素时,平均查找长度(及x同元素的平均比较次数,假定查找每个元素的概率都相等)为 C 。

A. nB. n/2C. (n+1)/2D. (n-1)/26、在顺序表中,只要知道 D ,就可以求出任一结点的存储地址。

A. 基地址B. 结点大小C. 向量大小D. 基地址和结点大小7、将两个各有n个元素的有序表归并为一个有序表,其最少的比较次数是 A 。

A. nB. 2n-1C. 2nD. n-18、线性表采用链表存储时其存储地址要求 D 。

A. 必须是连续的B. 部分地址必须是连续的C. 必须是不连续的D. 连续的和不连续的都可以9、下面关于线性表的描述中,错误的是 B 。

A. 线性表采用顺序存储,必须占用一片连续的存储单元B. 线性表采用顺序存储,便于进行插入和删除操作C. 线性表采用链式存储,不必占用一片连续的存储单元D. 线性表采用链式存储,便于插入和删除操作10、向具有n个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是 BA. O(1)B. O(n)C. O(n2)D. O(log2n)11、在一个带头结点的单链表HL中,若要向表头插入一个由指针p指向的结点,则执行的语句是 D 。

kmp 最小循环节

kmp 最小循环节

kmp 最小循环节(最新版)目录1.KMP 算法简介2.最小循环节的概念3.KMP 算法与最小循环节的关系4.KMP 算法的应用实例5.总结正文1.KMP 算法简介KMP(Knuth-Morris-Pratt)算法是一种字符串匹配算法,用于在一个主字符串中查找一个子字符串出现的位置。

该算法的关键在于通过部分匹配串的 next 数组来避免无效的匹配过程,从而提高匹配效率。

2.最小循环节的概念最小循环节是指一个字符串中最短的连续重复子串。

例如,字符串"ababc"的最小循环节是"ab"。

在 KMP 算法中,最小循环节的概念被用来构建 next 数组,以加速字符串匹配过程。

3.KMP 算法与最小循环节的关系KMP 算法利用最小循环节的性质来避免无效的匹配过程。

在构建next 数组时,如果某个字符在主字符串中出现,那么它之前的所有字符都必须与子字符串中的对应字符匹配。

这样,在匹配过程中,如果发现某个字符不匹配,可以根据 next 数组跳过已经匹配的部分,从而减少无效匹配的次数。

4.KMP 算法的应用实例假设要在字符串"abcabcabc"中查找子字符串"abc"的位置,使用 KMP 算法可以得到如下 next 数组:{0, 1, 0, 1, 0, 1}。

在匹配过程中,发现第二个字符不匹配,根据 next 数组,跳过已经匹配的"abc",继续匹配剩余的"abc",最终得到匹配位置为 3。

5.总结KMP 算法是一种高效的字符串匹配算法,它利用最小循环节的性质来避免无效的匹配过程。

kni算法

kni算法

kmp算法kmp算法是一种改进的字符串匹配算法,由D.E.Knuth与V.R.Pratt和J.H.Morris同时发现,因此人们称它为克努特——莫里斯——普拉特操作(简称KMP算法)。

KMP算法的关键是根据给定的模式串W1,m,定义一个next函数。

next函数包含了模式串本身局部匹配的信息。

目录编辑本段详细算法:一般的KMP算法现在讨论一般情况。

假设主串:s: ‘s(1) s(2) s(3) ……s(n)’ ; 模式串:p: ‘p(1) p(2) p(3)…..p(m)’把课本上的这一段看完后,继续现在我们假设主串第i个字符与模式串的第j(j<=m)个字符‘失配’后,主串第i个字符与模式串的第k(k<j)个字符继续比较此时,s(i)≠p(j), 有主串:S(1)…… s(i-j+1)…… s(i-1) s(i) ………….|| (相配) || ≠(失配)匹配串: P(1) ........... p(j-1) p(j)由此,我们得到关系式‘p(1) p(2) p(3)…..p(j-1)’ = ’ s(i-j+1)……s(i-1)’由于s(i)≠p(j),接下来s(i)将与p(k)继续比较,则模式串中的前(k-1)个字符的子串必须满足下列关系式,并且不可能存在k’>k 满足下列关系式:(k<j),‘p(1) p(2) p(3)…..p(k-1)’ = ’ s(i-k+1)s(i-k+2)……s(i-1)’ 即:主串:S(1)……s(i-k +1) s(i-k +2) ……s(i-1) s(i) ………….|| (相配) || || ?(有待比较)匹配串:P(1) p(2) ……..... p(k-1) p(k)现在我们把前面总结的关系综合一下有:S(1)…s(i-j +1)… s(i-k +1) s(i-k +2) …… s(i-1) s(i) ……|| (相配) || || || ≠(失配)P(1) ……p(j-k+1) p(j-k+2) …...... p(j-1) p(j)|| (相配) || || ?(有待比较)P(1) p(2) ……...... p(k-1) p(k)由上,我们得到关系:'p(1) p(2) p(3)…..p(k-1)’ = ' p(j-k+1)p(j-k+2)……p(j-1)’ 接下来看“反之,若模式串中存在满足式(4-4)。

2022年武昌工学院计算机科学与技术专业《数据结构与算法》科目期末试卷A(有答案)

2022年武昌工学院计算机科学与技术专业《数据结构与算法》科目期末试卷A(有答案)

2022年武昌工学院计算机科学与技术专业《数据结构与算法》科目期末试卷A(有答案)一、选择题1、无向图G=(V,E),其中:V={a,b,c,d,e,f},E={(a,b),(a, e),(a,c),(b,e),(c,f),(f,d),(e,d)},对该图进行深度优先遍历,得到的顶点序列正确的是()。

A.a,b,e,c,d,fB.a,c,f,e,b,dC.a,e,b,c,f, dD.a,e,d,f,c,b2、n个结点的完全有向图含有边的数目()。

A.n*nB.n(n+1)C.n/2D.n*(n-1)3、算法的计算量的大小称为计算的()。

A.效率B.复杂性C.现实性D.难度4、向一个栈顶指针为h的带头结点的链栈中插入指针s所指的结点时,应执行()。

A.h->next=sB.s->next=hC.s->next=h;h->next=sD.s->next=h-next;h->next=s5、下面关于串的叙述中,不正确的是()。

A.串是字符的有限序列B.空串是由空格构成的串C.模式匹配是串的一种重要运算D.串既可以采用顺序存储,也可以采用链式存储6、若一棵二叉树的前序遍历序列为a,e,b,d,c,后序遍历序列为b, c,d,e,a,则根结点的孩子结点()。

A.只有e B.有e、b C.有e、c D.无法确定7、循环队列放在一维数组A中,end1指向队头元素,end2指向队尾元素的后一个位置。

假设队列两端均可进行入队和出队操作,队列中最多能容纳M-1个元素。

初始时为空,下列判断队空和队满的条件中,正确的是()。

A.队空:end1==end2;队满:end1==(end2+1)mod MB.队空:end1==end2;队满:end2==(end1+1)mod (M-1)C.队空:end2==(end1+1)mod M;队满:end1==(end2+1) mod MD.队空:end1==(end2+1)mod M;队满:end2==(end1+1) mod (M-1)8、一个具有1025个结点的二叉树的高h为()。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 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
相关文档
最新文档