[暂定]KMP总结

算是正式开始学习的第一个算法，遇到了诸多困难，花了许多时间逐一解决，故整理思路留此文以便后来翻阅。

第一部分 字符串匹配

1、朴素的模式匹配BF算法与KMP算法的时间复杂度比较

    KMP算法是一种线性时间复杂的字符串匹配算法，它是对BF算法（Brute-Force，最基本的字符串匹配算法的）改进。对于给的原始串S和模式串P，需要从字符串S中找到字符串P出现的位置的索引。

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

KMP算法的时间复杂度O(strlen(S) + strlen(T))，空间复杂度O(strlen(T))。

2、BF算法与KMP算法的区别

    假设现在S串匹配到i位置，T串匹配到j位置。那么总的来说，两种算法的主要区别在于失配的情况下，对j的值做的处理：

   BF算法中，如果当前字符匹配成功，即s[i+j] == T[j]，令j++，继续匹配下一个字符；如果失配，即S[i + j] != T[j]，需要让i++,并且j= 0，即每次匹配失败的情况下，模式串T相对于原始串S向右移动了一位。

代码实现：

int Index(char s[], char p[], int pos)  
{    
	int i, j, slen, plen;    
	i = pos;    
	j = 0;    
	slen = strlen(s);    
	plen = strlen(p);    
	while (i<slen&&j<plen)    
	{    
		if((s[i]==p[j]))    
		{    
			i++;    
			j++;    
		}    
		else    
		{    
			i = i-j+1;    
			j = 0; 
		}    
	}    
	if(j>=plen)    
		return i-plen+1;
	else 
		return -1;       
}    

 而KMP算法中，如果当前字符匹配成功，即S[i]==T[j]，令i++，j++，继续匹配下一个字符；

如果匹配失败，即S[i] != T[j]，需要保持i不变，并且让j = next[j]，这里next[j] <=j -1，即模式串T相对于原始串S向右移动了至少1位(移动的实际位数j - next[j]  >=1),    如果下次匹配是基于T向右移动一位，那么i之前的部分（即S[i-j+1 ~ i-1]），和j=next[j]之前的部分（即T[0 ~ j-2]）仍然相等。

显然，相对于BF算法来说，KMP移动更多的位数，起到了一个加速的作用！ (失配的特殊情形，令j=next[j]导致j==0的时候，需要将i ++，否则此时没有移动模式串)。

二 KMP

1、KMP 算法思想

KMP算法的本质便是：每一次匹配都是基于前一次匹配的结果，如何更好地利用这前一次匹配的结果呢？针对待匹配的模式串的特点，判断它是否有重复的字符，从而找到它的前缀与后缀，进而求出相应的Next数组，最终根据Next数组而进行KMP匹配。

 KMP算法借助于一个辅助数组next来确定当匹配过程中出现不等时，模式P右移的位置和开始比较的位置。next[i]的取值只与模式P本身的前i+1项有关，而与目标T无关。匹配过程中遇到Pi不等于Tj时，若next[i]>=0，则应将P右移i-next[i]位个字符，用P中的第next[i]个字符与Tj 进行比较；若：next[i]= -1，P中的任何字符都不必再与Tj比较，而应将P右移i+1个字符，从P0和Tj+1从新开始下一轮比较(可能不太好理解，自己找个例子，对着话一句一句试试看)

这种想法基于如下事实的：p[j]!=s[i]前，p[0]~p[j-1]跟s[i-j]~s[i-1]是匹配的（这里j>0，也就是说在不匹配前已经有匹配的字符了。否则如果j=0,则主串指针肯定不用回溯，直接向前变成i+1再跟p[0]比较就是了）  
   
  p[j]!=s[i]前，p[0]~p[j-1]跟s[i-j]~s[i-1]是匹配的，这说明了什么呢？这说明可以通过分析模式的p[0]~p[j-1]来分析s[i-j]~s[i-1]。

如果模式中存在p[0]~p[k-1]=p[j-k]~p[j-1](共k个匹配的字符,且k是满足这个关系的最大值）,则可以知道s[i-k]~s[j-1]跟[0]~p[k-1]是匹配的，那么，s[i]只需要跟p[k]进行比较就行了。而这个k是跟主串无关的，只需要分析模式串就可以求出来（这就是普通的教材中next[j]=k这个假设的由来,普通教材中总喜欢假设这个k值已经有了，如果你逻辑思维强还没有什么，不然或多或少会把你卡在这的）。亦即next[j]=k。  
   
  如果上述的p[0]~p[k-1]=p[j-k]~p[j-1]串不存在会怎么样呢？这说明p[j]前的串中不存在p[0]...=...p[j-1]的情况，就连p[0]也不等于p[j-1],也就是说p[0]~p[j-1]中所有以p[j-1]为结尾的子串跟模式p都是失配的。基于上面p[0]~p[j-1]=s[i-j]~s[i-1]的事实，可以断定s[i-j]~s[i-1]中所有以s[i-1]结尾的子串跟模式p都是失配，这说明把主串的指针回溯到i-j+1～i-1都是没有必要的，既然没有必要回溯，而s[i]!=p[j]，则s[i只能跟p[0]进行比较匹配了。亦即next[j]=0。  
   
  特殊情况下，j=0，即s[i]!=p[0]，这时不用再用s[i]来跟p中的其它字符比较了，变成用s[i+1]跟p[0]进行比较。为了统一，可以让next[0]=-1。在下一轮的比较中，判断到j=-1的情况时，让i=i+1,j=j+1,自然就形成s[i+1]跟p[0]比较的效果了。  
   
  现在回过头来看教材上的next[j]的定义  
   
                              |－   -1,         当   j   =   0时  
          next[j]   =   |－   max{k   |   0   <   k   <   j   且   'p[0]...p[k-1]'   =   'p[j-k+1]...p[j-1]'   }  
                              |－   0,           其它情况  
                               
  是不是很容易理解呢？  
   
  时候再来看KMP的算法实现  

int Index(char s[], char p[], int pos, int next[])  
{  
	int i, j, slen, plen;  
	i = pos;  
	j = 0;  
	slen = strlen(s);  
	plen = strlen(p);  
	while (i<slen&&j<plen)  
	{  
		if((j==-1)||(s[i]==p[j]))  
		{  
			i++;  
			j++;  
		}  
		else   
			j=next[j];   
	}  
	if(j>=plen)  
		return(i-plen+1);  
	else  
		return-1;  
}  

   根据上面的推导，知道next[0]=-1。  
  如果已经知道next[j]=k，那么说明p[0]~p[k-1]=p[j-k]~p[j-1]，现在next[j+1]应该是多少呢？  
   
  若p[k]=p[j]，说明p[0]~p[k]=p[j-k]~p[j]成立，则有next[j+1]=k+1。  
   
  若p[k]!=p[j],即p[0]~p[k-1]!=p[j-k]~p[j-1]，从KMP算法的角度来看，这时应p[j]应该跟p[next[k]]进行比较。也就是k=next[k]，如此重复，由于next[k]<k，故最终必然是k=-1或p[k]=p[j]。如果是k=-1,则next[j+1]=0,否则next[j+1]=k+1，可以统一为next[j+1]=k+1。  
   
  下面就是GetNext函数的实现：  

void GetNext(char p[],int next[])    
{    
	int   i,   j,   slen;    
	slen = strlen(p);    
	i = 0;    
	j = -1;    
	next[0] = -1;    
	while (i<slen)    
	{    
		if((j==-1)||(p[i]==p[j]))    
		{    
			i++;    
			j++;    
			next[i] = j;    
		}    
		else    
		{    
			j = next[j];    
		}    
	}    
}    

 

参考文章

KMP算法

KMP next（j） （伟大的转折点）

经典算法研究系列：六、教你初步了解KMP算法

六之续、由KMP算法谈到BM算法

六之再续：KMP算法之总结篇