精华内容
下载资源
问答
  • 数据结构KMP算法

    2013-11-21 09:52:39
    数据结构里面的KMP算法,这是在VC6.0里面边写的,上传的是一个工程,可以直接使用的
  • 数据结构 KMP算法

    2021-01-20 14:51:21
    1、KMP算法的用途 KMP算法是用来找出a字符串中的b字符串,其中a叫做文本串,b叫做模式串 KMP算法是如何在a文本串中找出b模式串的呢? 如图所示:当将模式串与文本串一一进行对比时,如果出现匹配不上的情况时,...

    1、KMP算法的用途

    KMP算法是用来找出a字符串中的b字符串,其中a叫做文本串b叫做模式串

    KMP算法是如何在a文本串中找出b模式串的呢?

    如图所示:当将模式串与文本串一一进行对比时,如果出现匹配不上的情况时,模式串找到b继续搜索,那么如何能够找到b呢?

     2、前缀表

    要找到b就要先立即前缀表的概念,如下图所示:模式串除去最后一个字母,然后顺序排列就是其前缀,注意不包含尾字母。

    3、后缀表

    模式串除去首位一个字母,然后顺序排列就是其前缀,注意不包含首字母。

    4、求模式串的最长相等前后缀

    观察模式串,是否有相等的前后缀,然后观察长度,找到长度的最大值,此时便可以得到前缀表:010120

    然后利用前缀表的最长长度去找b这个值。因为索引是从0开始的,所以最长的前缀的后一个字母的坐标就是最长前缀的长度。

    然后从b开始向后匹配,我们就可以完成匹配的过程。

    那么具体怎么操作呢?

    首先将前缀表达式装入一个叫做next的数组

    然后对next中的元素统一执行减一操作:

    执行操作完成后next就是前缀表。

    求next数组的步骤:

    1、初始化next数组

    2、求出前后缀相同的情况和前后缀不同的情况

    3、更新next数组

     

    初始化next数组

    首先来理解一下的概念,当目前的next数组是1的时候,在什么时候它会变成2?

     仔细思考过后,就需要判断下标为6的那个值是否是B如果是B那对对应位置的前缀表就变成2。

    那么如何让程序执行这个思考过程呢?

    我们可以看到下标为5的地方其前缀表的值是1,那么由于前缀表的值也是其对应的相同前缀的最后一个值的下一个值的坐标,因此此时坐标1下的值就用来判断是否和坐标6下的值是否相等。

    定义相同前后缀的后一个值的坐标为len,由上方我们的分析可知,len=1;

    len的值说的是最大相同前后缀的长度。

    那么就有如下的代码来计算len的值

    那么如果最大相同前后串的下一个值不等于i的下一值的时候,我们应该怎么办?

    如下图:

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 4.3.2 KMP 算法 KMP 算法是 D.E.Knuth J.H.Morris 和 V .R.Pratt 共同提出的 , 简称 KMP 算法算法较 BF 算法有较 大改进 , 主要是消除了主串指针的回溯 , 从而使算法效 率有了某种程度的提高 所谓 真子串 是指模式...
  • 数据结构 KMP 算法实现 KMP 算法关键是要求出next数组下面是求next数组的算法 n利用next[0]= -1,…,next[i] 求next[i+1] 的算法: 假设 k =next [i],  1) 若pk = pi, 则 p0… pi-k…pi 中最大相同前后缀长度...

    数据结构 KMP 算法实现

    KMP 算法关键是要求出next数组下面是求next数组的算法

    n利用next[0]= -1,…,next[i] 求next[i+1] 的算法:

         假设 k =next [i],

       1) 若pk = pi, 则 p0… pi-k…pi 中最大相同前后缀长度为next[i+1] = k+1

      2)若pk ¹ pi ,置 k=next[k] ,然后转到 第1步.

        (设 k = next[k],就是考虑前一个更短的匹配前缀,从那里继续向下检查)

      3)若 k 值(来自next)为-1,就得到p0… pi-k…pi中最大相同前后缀的长度为k = 0(即next [i+1] = 0)

    对求next数组的改进

      n当 pi !=  tj 时,若pi == pk, 那么一定有 pk != tj .所以模式串应再向右移 k-next[k]位,下一步用 pnext[k] 与tj比较
      n对于next[i]=k 的改进:
    if  (pk== pi)  
        next[i] = next[k];
    else  
        next[i]=k;

      这一改进可以避免一些不必要的操作.

     

    下面是一个例子:

     1 /*============================================================================*\
     2  *
     3  *                     数据结构基础练习
     4  * 
     5  *                        KMP 算法测试 
     6  * 
     7  *                    2013-05-20 by 樊列龙 
     8  *
     9 \*============================================================================*/
    10 
    11 #include <iostream>
    12 
    13 using namespace std;
    14 
    15 void set_next(char* p, int* next)
    16 {
    17     int i = 0, j= -1;
    18     next[0] = -1;
    19     
    20     while(p[i])
    21     {
    22         while(j >= 0 && p[i] != p[j])
    23         {
    24             j = next[j];
    25         }
    26         i++,j++;
    27         if(p[i] == p[j]) next[i] = next[j];
    28         else next[i] = j;
    29         
    30     }
    31 }
    32 
    33 int KMP(char* s, char* p, int *next, int n)
    34 {
    35     int i = 0,j = 0;
    36     int count = 0;
    37     while(s[i] && j < n)
    38     {
    39         if(j == -1 || s[i] == p[j])
    40         {
    41             j++,i++;
    42             count++;
    43         }
    44         else
    45         {
    46             j = next[j];
    47         }
    48     }
    49     
    50     if(j >= n)
    51     {
    52         return i-n+1;
    53     }
    54     
    55     return 0;
    56 }
    57 
    58 int main()
    59 {
    60     char s[] = "abaabca8934baaabaabc23abaabcaca2312";
    61     char p[] = "abaabcac";//8个字符 
    62     int next[100];
    63 
    64     set_next(p,next);
    65     cout << KMP(s,p,next,sizeof(p)-1) << endl;
    66     
    67     return 0;
    68 }

    结果:

    23
    

      

     

     

    转载于:https://www.cnblogs.com/CocoonFan/archive/2013/05/20/3087913.html

    展开全文
  • 数据结构KMP算法配图详解(超详细)

    千次阅读 多人点赞 2020-02-18 22:02:42
    KMP算法是我们数据结构串中最难也是最重要的算法。难是因为KMP算法的代码很优美简洁干练,但里面包含着非常深的思维。真正理解代码的人可以说对KMP算法的了解已经相当深入了。而且这个算法的不少东西的确不容易讲懂...

    KMP算法配图详解

    前言

    KMP算法是我们数据结构串中最难也是最重要的算法。难是因为KMP算法的代码很优美简洁干练,但里面包含着非常深的思维。真正理解代码的人可以说对KMP算法的了解已经相当深入了。而且这个算法的不少东西的确不容易讲懂,很多正规的书本把概念一摆出直接劝退无数人。这篇文章将尽量以最详细的方式配图介绍KMP算法及其改进。文章的开始我先对KMP算法的三位创始人Knuth,Morris,Pratt致敬,懂得这个算法的流程后你真的不得不佩服他们的聪明才智。

    KMP解决的问题类型

    KMP算法的作用是在一个已知字符串中查找子串的位置,也叫做串的模式匹配。比如主串s=“goodgoogle”,子串t=“google”。现在我们要找到子串t 在主串s 中的位置。大家肯定觉得这还不简单,不就在第五个嘛,一眼就看出来了。
    当然,在字符串非常少时,“肉眼观察法”不失为一个好方法。但如果要你在一千行文本里找一个单词,我想一般人都会数得崩溃吧。这就让我想起来考试的时候,如果一两道选择题不会。这时候,“肉眼观察法”可能效果不错,但是如果好几道大题不会呢?“肉眼观察法”就丝毫不起效了。所以打铁还需自身硬,我们把这种枯燥的事以一定的算法交给计算机处理。
    第一种我们容易想到的就是暴力求解法。
    这种方法也叫朴素的模式匹配

    简单来说就是:从主串s 和子串t 的第一个字符开始,将两字符串的字符一一比对,如果出现某个字符不匹配,主串回溯到第二个字符,子串回溯到第一个字符再进行一一比对。如果出现某个字符不匹配,主串回溯到第三个字符,子串回溯到第一个字符再进行一一比对…一直到子串字符全部匹配成功。

    下面我们通过图片展示这个过程:
    竖直线表示相等,闪电线表示不等
    第一个过程:子串“goo”部分与主串相等,'g’不等,结束比对,进行回溯。
    在这里插入图片描述
    第二个过程:开始时就不匹配,直接回溯
    在这里插入图片描述
    第三个过程:开始时即不匹配,直接回溯
    在这里插入图片描述
    第四个过程:开始时即不匹配,直接回溯
    在这里插入图片描述
    第五个过程:匹配成功
    在这里插入图片描述
    大家可能会想:这个方法也太慢了吧!求一个子串位置需要太多的步骤。而且很多步骤根本不必要进行。
    这个想法非常好!!很多伟大的思想都是在一步步完善更正已有方法中诞生的。这种算法在最好情况下时间复杂度为O(n)。即子串的n个字符正好等于主串的前n个字符,而最坏的情况下时间复杂度为O(m*n)。相比而言这种算法空间复杂度为O(1),即不消耗空间而消耗时间。

    下面就开始进入我们的正题:KMP算法是怎样优化这些步骤的。其实KMP的主要思想是:“空间换时间”。
    大家打起精神,认真看下面的内容
    首先,为什么朴素的模式匹配这么慢呢?
    你再回头看一遍就会发现,哦,原来是回溯的步骤太多了。所以我们应该尽量减少回溯的次数。
    怎样做呢?比如上面第一个图:当字符’d’与’g’不匹配,我们保持主串的指向不变,
    主串依然指向’d’,而把子串进行回溯,让’d’与子串中’g’之前的字符再进行比对。
    如果字符匹配,则主串和子串字符同时右移。
    至于子串回溯到哪个字符,这个问题我们先放一放。

    我先提出一个概念:一个字符串最长相等前缀和后缀。
    教科书常用的手段是:在此处摆出一堆数学公式让大家自行理解。
    在这里插入图片描述
    这也是为什么看计算机学科的书没有较好的数学基础会很痛苦。(当初我为什么不好好学数学T_T)
    大家先不要强行理解数学公式,且听我慢慢道来:
    我给大家个例子。
    字符串 abcdab
    前缀的集合:{a,ab,abc,abcd,abcda}
    后缀的集合:{b,ab,dab,cdab,bcdab}
    那么最长相等前后缀不就是ab嘛.

    做个小练习吧:
    字符串:abcabfabcab中最长相等前后缀是什么呢:
    对就是abcab
    好了我们现在会求一个字符串的前缀,后缀以及最长相等前后缀了。
    这个概念很重要。到这里如果都看懂了,可以鼓励一下自己,然后回想一遍,再往下看。
    之前留了一个问题,子串回溯到哪个字符,现在可以着手解决了。

    图解KMP

    现在我们先看一个图:第一个长条代表主串,第二个长条代表子串。红色部分代表两串中已匹配的部分,
    绿色和蓝色部分分别代表主串和子串中不匹配的字符。
    再具体一些:这个图代表主串"abcabeabcabcmn"和子串"abcabcmn"。
    在这里插入图片描述
    在这里插入图片描述
    现在发现了不匹配的地方,根据KMP的思想我们要将子串向后移动,现在解决要移动多少的问题。
    之前提到的最长相等前后缀的概念有用处了。因为红色部分也会有最长相等前后缀。如下图:
    在这里插入图片描述
    在这里插入图片描述
    灰色部分就是红色部分字符串的最长相等前后缀,我们子串移动的结果就是让子串的红色部分最长相等前缀和主串红色部分最长相等后缀对齐。
    在这里插入图片描述
    在这里插入图片描述
    这一步弄懂了,KMP算法的精髓就差不多掌握了。接下来的流程就是一个循环过程了。事实上,每一个字符前的字符串都有最长相等前后缀,而且最长相等前后缀的长度是我们移位的关键,所以我们单独用一个next数组存储子串的最长相等前后缀的长度。而且next数组的数值只与子串本身有关。
    所以next[i]=j,含义是:下标为i 的字符前的字符串最长相等前后缀的长度为j。
    我们可以算出,子串t= "abcabcmn"的next数组为next[0]=-1(前面没有字符串单独处理)
    next[1]=0;next[2]=0;next[3]=0;next[4]=1;next[5]=2;next[6]=3;next[7]=0;

    a b c a b c m n
    next[0] next[1] next[2] next[3] next[4] next[5] next[6] next[7]
    -1 0 0 0 1 2 3 0

    本例中的蓝色c处出现了不匹配(是s[5]!=t[5]),
    在这里插入图片描述
    我们把子串移动,也就是让s[5]与t[5]前面字符串的最长相等前缀后一个字符再比较,而该字符的位置就是t[?],很明显这里的?是2,就是不匹配的字符前的字符串 最长相等前后缀的长度。
    在这里插入图片描述
    也是不匹配的字符处的next数组next[5]应该保存的值,也是子串回溯后应该对应的字符的下标。 所以?=next[5]=2。接下来就是比对是s[5]和t[next[5]]的字符。这里也是最奇妙的地方,也是为什么KMP算法的代码可以那么简洁优雅的关键。
    我们可以总结一下,next数组作用有两个:
    一是之前提到的,

    next[i]的值表示下标为i的字符前的字符串最长相等前后缀的长度。

    二是:

    表示该处字符不匹配时应该回溯到的字符的下标

    next有这两个作用的源头是:之前提到的字符串的最长相等前后缀
    想一想是不是觉得这个算法好厉害,从而不得不由衷佩服KMP算法的创始人们。

    KMP算法的时间复杂度

    现在我们分析一下KMP算法的时间复杂度:
    KMP算法中多了一个求数组的过程,多消耗了一点点空间。我们设主串s长度为n,子串t的长度为m。求next数组时时间复杂度为O(m),因后面匹配中主串不回溯,比较次数可记为n,所以KMP算法的总时间复杂度为O(m+n),空间复杂度记为O(m)。相比于朴素的模式匹配时间复杂度O(m*n),KMP算法提速是非常大的,这一点点空间消耗换得极高的时间提速是非常有意义的,这种思想也是很重要的。
    下面还有更厉害的,我们一起来分析具体的代码。

    求next数组的代码

    下面我们一起来欣赏计算机如何求得next数组的

    typedef struct
    {	
    	char data[MaxSize];
    	int length;			//串长
    } SqString;
    //SqString 是串的数据结构
    //typedef重命名结构体变量,可以用SqString t定义一个结构体。
    void GetNext(SqString t,int next[])		//由模式串t求出next值
    {
    	int j,k;
    	j=0;k=-1;
    	next[0]=-1;//第一个字符前无字符串,给值-1
    	while (j<t.length-1) 
    	//因为next数组中j最大为t.length-1,而每一步next数组赋值都是在j++之后
    	//所以最后一次经过while循环时j为t.length-2
    	{	
    		if (k==-1 || t.data[j]==t.data[k]) 	//k为-1或比较的字符相等时
    		{	
    			j++;k++;
    			next[j]=k;
    			//对应字符匹配情况下,s与t指向同步后移
    			//通过字符串"aaaaab"求next数组过程想一下这一步的意义
    			//printf("(1) j=%d,k=%d,next[%d]=%d\n",j,k,j,k);
           	}
           	else
    		{
    			k=next[k];
    			**//我们现在知道next[k]的值代表的是下标为k的字符前面的字符串最长相等前后缀的长度
    			//也表示该处字符不匹配时应该回溯到的字符的下标
    			//这个值给k后又进行while循环判断,此时t.data[k]即指最长相等前缀后一个字符**
    			//为什么要回退此处进行比较,我们往下接着看。其实原理和上面介绍的KMP原理差不多
    			//printf("(2) k=%d\n",k);
    		}
    	}
    }
    

    解释next数组构造过程中的回溯问题

    大家来看下面的图:
    下面的长条代表子串,红色部分代表当前匹配上的最长相等前后缀,蓝色部分代表t.data[j]。
    在这里插入图片描述在这里插入图片描述

    KMP算法代码解释

    int KMPIndex(SqString s,SqString t)  //KMP算法
    {
    
    	int next[MaxSize],i=0,j=0;
    	GetNext(t,next);
    	while (i<s.length && j<t.length) 
    	{
    		if (j==-1 || s.data[i]==t.data[j]) 
    		{
    			i++;j++;  			//i,j各增1
    		}
    		else j=next[j]; 		//i不变,j后退,现在知道为什么这样让子串回退了吧
        }
        if (j>=t.length)
    		return(i-t.length);  	//返回匹配模式串的首字符下标
        else  
    		return(-1);        		//返回不匹配标志
    }
    

    KMP算法的改进

    为什么KMP算法这么强大了还需要改进呢?
    大家来看一个例子:
    主串s=“aaaaabaaaaac”
    子串t=“aaaaac”
    这个例子中当‘b’与‘c’不匹配时应该‘b’与’c’前一位的‘a’比,这显然是不匹配的。'c’前的’a’回溯后的字符依然是‘a’。
    我们知道没有必要再将‘b’与‘a’比对了,因为回溯后的字符和原字符是相同的,原字符不匹配,回溯后的字符自然不可能匹配。但是KMP算法中依然会将‘b’与回溯到的‘a’进行比对。这就是我们可以改进的地方了。我们改进后的next数组命名为:nextval数组。KMP算法的改进可以简述为: 如果a位字符与它next值指向的b位字符相等,则该a位的nextval就指向b位的nextval值,如果不等,则该a位的nextval值就是它自己a位的next值。 这应该是最浅显的解释了。如字符串"ababaaab"的next数组以及nextval数组分别为:

    下标 0 1 2 3 4 5 6 7
    子串 a b a b a a a b
    next -1 0 0 1 2 3 1 1
    nextval -1 0 -1 0 -1 3 1 0

    我们来分析下代码:

    void GetNextval(SqString t,int nextval[])  
    //由模式串t求出nextval值
    {
    	int j=0,k=-1;
    	nextval[0]=-1;
       	while (j<t.length) 
    	{
           	if (k==-1 || t.data[j]==t.data[k]) 
    		{	
    			j++;k++;
    			if (t.data[j]!=t.data[k]) 
    //这里的t.data[k]是t.data[j]处字符不匹配而会回溯到的字符
    //为什么?因为没有这处if判断的话,此处代码是next[j]=k;
    //next[j]不就是t.data[j]不匹配时应该回溯到的字符位置嘛
    				nextval[j]=k;
               	else  
    				nextval[j]=nextval[k];
    //这一个代码含义是不是呼之欲出了?
    //此时nextval[j]的值就是就是t.data[j]不匹配时应该回溯到的字符的nextval值
    //用较为粗鄙语言表诉:即字符不匹配时回溯两层后对应的字符下标
           	}
           	else  k=nextval[k];    	
    	}
    
    }
    
    int KMPIndex1(SqString s,SqString t)    
    //修正的KMP算法
    //只是next换成了nextval
    {
    	int nextval[MaxSize],i=0,j=0;
    	GetNextval(t,nextval);
    	while (i<s.length && j<t.length) 
    	{
    		if (j==-1 || s.data[i]==t.data[j]) 
    		{	
    			i++;j++;	
    		}
    		else j=nextval[j];
    	}
    	if (j>=t.length)  
    		return(i-t.length);
    	else
    		return(-1);
    }
    

    剩下的话

    在写这篇博客时,我想起了编译原理老师讲过的一些知识,其实KMP算法的步骤与自动机有不少相似之处,有兴趣的朋友不妨联系对比一下。

    展开全文
  • 上回说到数据结构-KMP算法,那么今天小编就带着相关真题来啦!(2015统考真题)已知字符串s为“abaabaabacacaabaabcc”,模式串t为“abaabc5’。采用KMP算法进行匹配,第一次出现“失配”(s[i]≠t[j])时,i=j=5,则...

    12e84d75790bb54a7cce9cdbf7d03908.png

    上回说到数据结构-KMP算法,那么今天小编就带着相关真题来啦!

    (2015统考真题)已知字符串s“abaabaabacacaabaabcc”,模式串t“abaabc5’。采用KMP算法进行匹配,第一次出现失配”(s[i]≠t[j])时,i=j=5,则下次开始匹配时,ij的值分别是(   )。

    A.i=1j=0                        B.i=5j=0

    C.i=5j=2                        D.i=6j=2

    解:

    首先要计算出模式串t的next数组

    j

    0

    1

    2

    3

    4

    5

    P[j]

    a

    b

    a

    a

    b

    c

    next[j]

    -1

    0

    0

    1

    1

    2

    第一躺匹配时i=5j=5失败:

    s: a  b  a  a  b  a  a  b  a  c  a  c  a  a  b  a  a  b  c  c

    t: a  b  a  a  b  c

    第二趟开始匹配时应该如下所示,可见i=5j=2:

    s: a  b  a  a  b  a  a  b  a  c  a  c  a  a  b  a  a  b  c  c

    t:          a  b  a  a  b  c

    答案为:C

    更多考研福利关注“计算机考研研究院”公众号点击“资料下载”即可拥有!

    467a2e39957e8b922633d5dcd5afb339.png

    72ca64b9aeb621192fc98a0e1677e2c9.gif

    ☀22研友加:1071300584

    ☀21研友加:723214845

    230bb9befe5a815b0257cdc33fc98457.png

    99df54f58d4c5efb397c72f10297854e.gif57523fd19574db68e408a96ddfbdc20d.gif

    ●考研计算机 | 数据结构—结构算法

    ●考研计算机 | 数据结构—研究内容

    ●考研计算机 | 数据结构—物理结构

    ●考研计算机 | 总线

    7200e70de919efc76e8b7370554f009c.png确认过眼神你是我爱的人更多考研资讯  关注我们就对了228e5ae88e22394090ece721a8b83f7a.png30c2f5ce77866fabfac705120f8b9650.png扫码关注我们ef17629931152087dda3b73a490a4a86.gif

    展开全文
  • 数据结构KMP算法例题

    2020-03-23 19:59:23
    今天遇到一个数据结构的问题,索性就把KMP算法的题总结一下,有不对的地方希望指正。 串“ababaabab”的nextval为( A)。 A.010104101 B.010102101 C.010100011 D.010101011 ①i从0开始 方法一: 第0位:Next[0]...
  • 拓展三 ...KMP算法 #include <stdio.h> typedef char* String; void get_next(String T,int *next) { int j=0; int i=1; next[1]=0; while(i<T[0]) { if(0==j || T[i]==T[j]) ...
  • 根据KMP算法的next数组值,推断模式字符串。 假设模式字符串中只存在0,1两种字符。给出首字符和next数组。请输出模式字符串。如果next数组不合法则输出ERROR Input Format 先输入模式字符串首字符0或者1,然后输入...
  • https://www.cnblogs.com/ZuoAndFutureGirl/p/9028287.html
  • kmp算法,可以加快找字串位置的速度。 为什么加快呢,因为在每次比较过程中,找到了模式串对称的小串,然后直接移过去。 比如,主串abcabcabe,模式串abcabe。 第一次,匹配到主串的第二个c,失败,然后根据前面串...
  • 数据结构 KMP算法代码

    千次阅读 2014-03-28 13:25:50
    //匹配字符串模式值  void getFail(char P[],int f[]) { int m=strlen(P); f[0]=0; f[1]=0; for(int i=1;i { int j=f[i]; while(j&&P[i]!=P[j])  j=f[j]; f[i+1] =P[i]==P[j] ?...//比较匹配算法 
  • 总结一下今天的收获(以王道数据结构书上的为例子,虽然我没看它上面的。。。):其中竖着的一列值是模式串前缀和后缀最长公共前缀。 最后求得的结果符合书上的结果,如果是以-1开头的话就不需要再加1,如果是以0...
  • 课程名称:数据结构 实验项目名称:串基本操作的实现 实验目的: 1.掌握串的模式匹配操作。 实验要求: 1、 分别使用BF和KMP算法完成串的模式匹配。 实验过程: 1、 设计完成next值的计算函数; 2、 ...
  • 课本 《数据结构(C语言版)(第2版)》 严蔚敏版 前言: 这次作业写的真是一个无语,课本印刷的代码就是错的,是不是自己上课没好好听讲,老师已经修改了? P95 的KMP算法有bug。 现将通过的程序贴出来,纪念一下...
  • 数据结构KMP算法中next函数的求解思想及其解释

    千次阅读 多人点赞 2016-04-10 20:09:02
    这个只是简单的next数组的求法,并没有完全实现KMP算法,有待改进
  • next数组的求解方法是:第一位的next值为0,第二位的next值为1,后面求解每一位的next值时,根据前一位进行比较。首先将前一位与其next值对应的内容进行比较,如果相等,则该位的next值就是前一位的next值加上1;...
  • 数据结构KMP算法

    2020-03-08 12:18:39
    数据结构KMP算法代码,并对KMP算法进行了改进优化,注释详细,易于理解,并附带举例说明。。。。。。
  • 数据结构与算法系列 数据结构与算法之哈希表 ...数据结构与算法之KMP算法 目录数据结构与算法系列数据结构与算法之哈希表数据结构与算法之跳跃表数据结构与算法之字典树数据结构与算法之2-3树数据结构与算法之平衡二叉.
  • 一步一步带你用Python实现KMP算法
  • KMP算法的前身---暴力破解法2.KMP算法的实现2.1 KMP算法的思路2.2 对模式串特征的描述2.3 next数组含义2.4 next数组的求法2.5 实现next表的创建2.6 KMP算法的实现2.7 KMP算法总结3.KMP算法的优化3.1 KMP算法的问题...
  • KMP算法 KMP算法是一个解决模式串在文本串中是否出现过,如果出现过,找出最早出现位置的经典算法 Knuth-Morris-Pratt字符串查找法,简称“KMP”算法,这个算法由DonaldKunth, Vaughan Pratt, James H.Morris三人于...
  • KMP算法 主串指针不回溯,只有模式串指针回溯。 所以不同的模式串对应不同的表。 观察:求模式串的next数组。 next数组:当模式串的第j个字符匹配失败时,令模式串跳到next[j]再继续匹配。 串的前缀:包含第一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,547
精华内容 1,018
关键字:

数据结构kmp算法

数据结构 订阅