KMP模式匹配

给你两个字符串，你该如何对比它们两个是否相等呢？朴素模式匹配算法地想法是一个字符一个字符地比，不对就移一下。比如abcdefgoogle和goole，g会依次和a、b一直到g相比，最后发现有一样地，证明子串是在目标字符串中的。但这样效率是不是有点低呢？比方说比较goolgoole，第一次比完后我是不是不需要再把g和o比较了？因为o和o匹配了，是否可以有一种方法可以直接跳过中间那些呢（详见下图）？

有三位前辈为我们完成了这一项工作，记住他们的名字：D.K.Knuth、J.H.Morris和V.R.Pratt。为了纪念他们的贡献，他们研究出来的算法就叫做克努特——莫里斯——普拉特算法，简称KMP算法。

我们继续按照上面举得那个例子来解释。先来看看我们的子串goole，首字母和后面是没有相同字符的，也就是说只要首字母后面的字符有和目标字符串有匹配的，但最后总的匹配不上，这时候我们的子串就没有必要一位一位地移动，可以直接跳到子串与目标字符串不匹配地地方重新匹配一次。
再来一个有重复字符出现地，假设我的子串是abcabe，目标字符串是abcabcabc…

第一次匹配发现就最后一个不一样，由于子串内有重复，于是继续跳到下一个ab处，因为那里也有ab，可能就在那个地方匹配到了。注意，右图中的红线其实是多余的，是不需要比较的，因为我在左图中子串的第二个ab和它匹配过，是一样的，所以我们没必要再比一次。

好了，到重头戏了，现在原理弄得差不多了，不就是不知道再怎么实现子串前后缀的相似度吗？我们设置一个next数组，其值如下所示：
| 0, j = 1
next[i] = | Max{k|1 < k < j, 且’p₁…p_k-1’ = ‘p_j-k+1…p_j-1’ } 当此集合不为空时
| 1, 其他情况
好了，公式给你了，我们来看一个具体的例子来感受一下：

1、当j = 1时，next[1] = 0；
2、当j = 2时，j由1到j - 1只有字符’a’，所以属于其他情况next[2] = 1；
3、当j = 3时，j由1到j - 1有’ab’，显然没有相等，所以还是next[3] = 1;
4、当j = 4时，j由1到j - 1有’abc’，显然没有相等，所以还是next[4] = 1;
5、当j = 5时，j由1到j - 1由’abca’，出现了相等的，p₁ = p₄，套用公式得到k - 1 = 1，所以k = 2，next[5] = 2;
6、当j = 6时，j由1到j - 1由’abcab’，出现了相等的，p₁p₂ = p₄p₅，套用公式得到k - 1 = 2，所以k = 3，next[5] = 3;
比较比的一定是最多相同的，比如下面这个例子：

前面几个都很正常地操作，到j = 6时我们来看看：
j = 6， j由1到j - 1由’ababa’，乍一看是最后一个和第一个一样，应该是next[6] = 2。但其实不然，把中间的a看作两次，那岂不是aba和aba匹配了？那不就是k - 1 = 3, k不就是4了？所以匹配时要是最多相同的！

这里还有一个规律：如果前后缀字符相等，k值是2，两个字符相等，k就是3，n个相等就是n+1！

好了，这个也知道了，那么如何通过代码实现呢？先上着，待会讲解：

/* 通过计算返回子串T的next数组。 */
void get_next(String T, int *next) 
{
	int i,j;
  	i=1;
  	j=0;
  	next[1]=0;
  	while (i<T[0])  /* 此处T[0]表示串T的长度 */
 	{
    	if(j==0 || T[i]== T[j]) 	/* T[i]表示后缀的单个字符，T[j]表示前缀的单个字符 */
		{
      		++i;  
			++j;  
			next[i] = j;
    	} 
		else 
			j= next[j];	/* 若字符不相同，则j值回溯 */
  	}
}

代码中的i代表j由1到j - 1的子串中后缀的单个字符，j则是前缀的。相等的话就会一直递增j，原理就是我们上面提到的规律。我一开始比较懵的是else的内容，else中的内容是这样的，如果目前的前后缀不匹配，则回溯到上一回前缀，经过while循环，最终会找到相等的或者是判断出前后并不匹配。
之后，我们再来看看其实现与目标字符串之间的匹配：

/* 返回子串T在主串S中第pos个字符之后的位置。若不存在，则函数返回值为0。 */
/*  T非空，1≤pos≤StrLength(S)。 */
int Index_KMP(String S, String T, int pos) 
{
	int i = pos;		/* i用于主串S中当前位置下标值，若pos不为1，则从pos位置开始匹配 */
	int j = 1;			/* j用于子串T中当前位置下标值 */
	int next[255];		/* 定义一next数组 */
	get_next(T, next);	/* 对串T作分析，得到next数组 */
	while (i <= S[0] && j <= T[0]) /* 若i小于S的长度并且j小于T的长度时，循环继续 */
	{
		if (j==0 || S[i] == T[j]) 	/* 两字母相等则继续，与朴素算法增加了j=0判断 */
      	{
         	++i;
         	++j; 
      	} 
      	else 			/* 指针后退重新开始匹配 */
      	 	j = next[j];/* j退回合适的位置，i值不变 */
	}
	if (j > T[0]) 
		return i-T[0];
	else 
		return 0;
}

这样就实现了KMP模式匹配。当然，并不是说所有的子串都适合用KMP，只有当我的子串与目标字符串之间存在许多“部分匹配”的情况下，用KMP才会体现出其优势！

该算法还是有改进空间的，比方说下面这个例子：

其匹配过程如下图：

由于我们第一次就知道a和b是不匹配的，于是也就没有必要再把a拿出来了，也就是说上面的图的第一个可以直接到最后一个，中间的都是多余过程，但更具KMP的确就是按照上面的六个步骤，那怎么办呢？我们稍微改进一下：

/* 求模式串T的next函数修正值并存入数组nextval */
void get_nextval(String T, int *nextval) 
{
  	int i,j;
  	i=1;
  	j=0;
  	nextval[1]=0;
  	while (i<T[0])  /* 此处T[0]表示串T的长度 */
 	{
    	if(j==0 || T[i]== T[j]) 	/* T[i]表示后缀的单个字符，T[j]表示前缀的单个字符 */
		{
      		++i;  
			++j;  
			if (T[i]!=T[j])      /* 若当前字符与前缀字符不同 */
				nextval[i] = j;	/* 则当前的j为nextval在i位置的值 */
      		else 
				nextval[i] = nextval[j];	/* 如果与前缀字符相同，则将前缀字符的 */
											/* nextval值赋值给nextval在i位置的值 */
    	} 
		else 
			j= nextval[j];			/* 若字符不相同，则j值回溯 */
  	}
}

至于匹配的那部分，只需要将代码里的get_next(T, next)改为get_nextval(T, next)就可以了。
下面我们结合具体例子来分析一下：

next[]数组还是不变的求法，
1、当j = 1时，nextval[1] = 0;
2、当j = 2时，由于第二位的字符是’b’的next值是1，然而第一位是’a’，不一样，所以保持和next[]数组一样的值。nextval[2] = next[2] = 1；
3、当j = 3时，由于第三位的字符是’a’，其next值是1，第一位是’a’，一样，所以nextval[3] = nextval[1] = 0；
…
简而言之就是说找到当前字符的next值i，找第i位的字符与当前比较，如果相同就把nextval[i]的值赋值给nextval[j]；不相同就保持当前next[]的值。