C++之KMP算法

转载：从头到尾彻底理解KMP：https://blog.csdn.net/v_july_v/article/details/7041827#

要解决的问题：有一个文本串S，和一个模式串P，查找P在S中的位置。

解决方法：

一、暴力匹配

思路：假设现在文本串S匹配到 i 位置，模式串P匹配到 j 位置，则有：

• 如果当前字符匹配成功（即S[i] == P[j]），则i++，j++，继续匹配下一个字符；
• 如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0。相当于每次匹配失败时，i 回溯，j 被置为0。

  int ViolentMatch(char* s, char* p)
  {
  	int sLen = strlen(s);
  	int pLen = strlen(p);
  	int i = 0;
  	int j = 0;
  
  	while (i < sLen && j < pLen)
  	{
  		if (s[i] == p[j])//①如果当前字符匹配成功（即S[i] == P[j]），则i++，j++    
  		{
  			i++;
  			j++;
  		}
  		else//②如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0  
  		{	  
  			i = i - j + 1;
  			j = 0;
  		}
  	}
  
  	//匹配成功，返回模式串p在文本串s中的位置，否则返回-1
  	if (j == pLen)
  		return i - j;
  	else
  		return -1;
  }
  

   

二、KMP算法 

思路：假设现在文本串S匹配到 i 位置，模式串P匹配到 j 位置：

• 如果j = -1，或者当前字符匹配成功（即S[i] == P[j]），都令i++，j++，继续匹配下一个字符；
• 如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j]。此举意味着失配时，模式串P相对于文本串S向右移动了j - next [j] 位。

next 数组值的含义：代表当前字符之前的字符串中，有多大长度的相同前缀。例如如果next [j] = k，代表j 之前的字符串中有最大长度为k 的相同前缀。

在某个字符失配时，该字符对应的next 值会告诉你下一步匹配中，模式串P应该跳到哪个位置（跳到next [j] 的位置）。如果next [j] 等于0或-1，则跳到模式串P的开头字符；若next [j] = k 且 k > 0，代表下次匹配跳到j 之前的某个字符，具体跳过了k 个字符。

①寻找最长前缀

ABCDABD（我们需要的是最后一列）

②根据①求next 数组

失配时，模式串向右移动的位数为：已匹配字符数 - 失配字符的上一位字符所对应的最大长度值

next数组（next 数组相当于①中的“最大长度值” 整体向右移动一位，然后初始值赋为-1）：

失配时，模式串向右移动的位数 = 失配字符的位置 - 失配字符对应的next 值

③通过代码递推计算next 数组

问题：已知next [0, ..., j]，如何求出next [j + 1]？

对于P的前j+1个序列字符：

• 若p[k] == p[j]，则next[j + 1 ] = next [j] + 1 = k + 1；

• 若p[k ] ≠ p[j]，如果此时p[ next[k] ] == p[j ]，则next[ j + 1 ] =  next[k] + 1，否则继续递归前缀索引k = next[k]，而后重复此过程。

相当于在字符p[j+1]之前不存在长度为k+1的前缀"p0 p1, …, pk-1 pk"跟后缀“pj-k pj-k+1, …, pj-1 pj"相等，那么是否可能存在另一个值t+1 < k+1，使得长度更小的前缀 “p0 p1, …, pt-1 pt” 等于长度更小的后缀 “pj-t pj-t+1, …, pj-1 pj” 呢？如果存在，那么这个t+1 便是next[ j+1]的值，此相当于利用已经求得的next 数组（next [0, ..., k, ..., j]）进行P串前缀跟P串后缀的匹配。

E的next 值为0

E对应的next 值为1

void GetNextval(char* p, int next[])
{
	int pLen = strlen(p);
	next[0] = -1;
	int k = -1;
	int j = 0;

	while (j < pLen - 1)
	{
		//p[k]表示前缀，p[j]表示后缀  
		if (k == -1 || p[j] == p[k])
		{
			++j;
			++k;
                        next[j] = k;

			/*代码优化，next[j] = k;改为下边的代码
			if (p[j] != p[k])
				next[j] = k;   //之前只有这一行
			else
		       //因为不能出现p[j] = p[ next[j ]]，所以当出现时需要继续递归，k = next[k] = next[next[k]]
				next[j] = next[k];*/
		}
		else
		{
			k = next[k];
		}
	}
}

KMP完整算法：

int KmpSearch(char* s, char* p)
{
	int i = 0;
	int j = 0;
	int sLen = strlen(s);
	int pLen = strlen(p);
	while (i < sLen && j < pLen)
	{
		//①如果j = -1，或者当前字符匹配成功（即S[i] == P[j]），都令i++，j++    
		if (j == -1 || s[i] == p[j])
		{
			i++;
			j++;
		}
		else
		{
			//②如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j]    
			//next[j]即为j所对应的next值      
			j = next[j];
		}
	}
	if (j == pLen)
		return i - j;
	else
		return -1;
}