KMP算法详解

  在文本编辑中，我们经常要在一段文本中某个特定的位置找出 某个特定的字符或模式。 由此，便产生了字符串的匹配问题。 首先，我们从简单的字符串匹配算法开始，再到KMP算法，由浅入深，教你从头到尾彻底理解KMP算法。

1.BF算法

  BF算法，即暴风(Brute Force)算法，是普通的模式匹配算法，BF算法的思想就是将目标串S的第一个字符与模式串T的第一个字符进行匹配，若相等，则继续比较S的第二个字符和 T的第二个字符；若不相等，则比较S的第二个字符和T的第一个字符，依次比较下去，直到得出最后的匹配结果。BF算法是一种蛮力算法。

#include<iostream>
#include<string>
using namespace std;

int match(const string& target, const string& pattern) {
	int target_length = target.size();        //目的字串
	int pattern_length = pattern.size();      //模式
	int target_index = 0; int pattern_index = 0; 

	while (target_index < target_length && pattern_index < pattern_length) 
	{ 
		if (target[target_index] == pattern[pattern_index]) 
		{ 
			++target_index; 
			++pattern_index; 
		} 
		else
		{ 
			target_index = target_index-pattern_index + 1;   //目的字串回退到原来开始匹配的位置+1，即现在失配的位置减去模式串已经匹配的位置+1
			pattern_index = 0;                     //模式子串回退到0
		} 
	} 

	if (pattern_index == pattern_length) 
	{ 
		return target_index - pattern_length; 
	}
	else
	{ 
		return -1; 
	}
}

int main()
{
	cout << match("banananobano", "nano") << endl;
	return 0;
}

  分析;在最坏情况下，此简单模式匹配算法的运行时间为O（(n-m+1)m）。
  我们主要把时间浪费在什么地方呢， 观查index = 2那一步，我们已经匹配了3个字符，而第4个字符是不匹配的，这时我们已经匹配的字符序列是nan, 此时如果向右移动一位，那么nan最先匹配的字符序列将是an,这肯定是不能匹配的， 之后再右移一位，匹配的是nan最先匹配的序列是n,这是可以匹配的。
  如果我们事先知道pattern本身的这些信息就不用每次匹配失败后都把target_index回退回去， 这种回退就浪费了很多不必要的时间，如果能事先计算出pattern本身的这些性质， 那么就可以在失配时直接把pattern移动到下一个可能的位置， 把其中根本不可能匹配的过程省略掉， 如上表所示我们在index=2时失配，此时就可以直接把pattern移动到index=4的状态， kmp算法就是从此出发。

2.KMP算法

2.1、 覆盖函数(overlay_function)
  覆盖函数所表征的是pattern本身的性质，可以让为其表征的是pattern从左开始的所有连续子串的自我覆盖程度。 比如如下的字串，abaabcaba

  由于计数是从0始的，因此覆盖函数的值为0说明有1个匹配，对于从0还是从1开始计数是偏好问题， 具体请自行调整，其中-1表示没有覆盖，那么何为覆盖呢，下面比较数学的来看一下定义，比如对于序列
         a₀a₁…a_j-1a_j
  要找到一个k,使它满足
         a₀a₁…a_k-1a_k = a_j-ka_j-k+1…a_j-1a_j
而没有更大的k满足这个条件，就是说要找到尽可能大k,使pattern前k字符与后k字符相匹配，k要尽可能的大， 原因是如果有比较大的k存在，而我们选择较小的满足条件的k， 那么当失配时，我们就会使pattern向右移动的位置变大，而较少的移动位置是存在匹配的，这样我们就会把可能匹配的结果丢失。
  计算这个overlay函数的方法可以采用递推，可以想象如果对于pattern的前j个字符，如果覆盖函数值为k
         a₀a₁…a_k-1a_k = a_j-ka_j-k+1…a_j-1a_j
则对于pattern的前j+1序列字符，则有如下可能
⑴ pattern[k+1]==pattern[j+1] 此时overlay(j+1)=k+1=overlay(j)+1，（表示下一个字符也匹配）
⑵ pattern[k+1]≠pattern[j+1] 此时只能在pattern前k+1个子符组所的子串中找到相应的overlay函数，h=overlay(k),如果此时pattern[h+1]==pattern[j+1],则overlay(j+1)=h+1否则重复(2)过程.

//模式串的覆盖数组
void compute_overlay(const string& pattern) 
{
	const int pattern_length = pattern.size(); 
	int *overlay_function = new int[pattern_length]; 
	int index; 
	overlay_function[0] = -1;  //初始化为-1
	for (int i = 1; i<pattern_length; ++i)
	{
		index = overlay_function[i - 1];   //将先前的失败位置k存储为索引
		while(index>=0 && pattern[i]!=pattern[index+1]) 
		{ 
			index = overlay_function[index]; 
		} 
		if(pattern[i]==pattern[index+1]) 
		{
			overlay_function[i] = index + 1;
		}
		else 
		{ 
			overlay_function[i] = -1; 
		} 
	} 

	for(int i=0;i<pattern_length;++i)
	{ 
		cout<<overlay_function[i]<<" "; 
	}
	cout << endl;

	delete[] overlay_function;
}

int main()
{
	string pattern = "abaabcaba";   //-1,-1,0,0,1,-1,0,1,2
	//cout << match("banananobano", "nano") << endl;
	compute_overlay(pattern);
	return 0;
}

2.2、kmp算法
  有了覆盖函数，那么实现kmp算法就是很简单的了，我们的原则还是从左向右匹配，但是当失配发生时，我们不用把target_index向回移动，target_index前面已经匹配过的部分在pattern自身就能体现出来，只要动pattern_index就可以了。
  当发生在j长度失配时，只要把pattern向右移动j-overlay(j)长度就可以了。如果失配时pattern_index==0，相当于pattern第一个字符就不匹配， 这时就应该把target_index加1，向右移动1位就可以了。

//模式串的覆盖数组
void compute_overlay(const string& pattern, int* &overlay_function)
{
	const int pattern_length = pattern.size(); 
	int index; 
	overlay_function[0] = -1;  //初始化为-1
	for (int i = 1; i<pattern_length; ++i)
	{
		index = overlay_function[i - 1];    //将先前的失配位置k存储为索引
		while(index>=0 && pattern[i]!=pattern[index+1]) 
		{ 
			index = overlay_function[index];   //失配则开始回退，index记录回退的位置
		} 
		if(pattern[i]==pattern[index+1])     //字符串相匹配
		{
			overlay_function[i] = index + 1;
		}
		else       //index < 0
		{ 
			overlay_function[i] = -1; 
		} 
	} 
}

int kmp_find(const string& target, const string& pattern) 
{
	const int target_length = target.size(); 
	const int pattern_length = pattern.size(); 
	int * overlay_value = new int[pattern_length]; 
	
	compute_overlay(pattern, overlay_value);

	int pattern_index = 0; 
	int target_index = 0; 

	while (pattern_index<pattern_length && target_index<target_length) 
	{ 
		if (target[target_index] == pattern[pattern_index]) 
		{ 
			++target_index; 
			++pattern_index; 
		} 
		else if (pattern_index == 0) 
		{ 
			++target_index;
		} 
		else
		{ 
			pattern_index = overlay_value[pattern_index - 1] + 1;
		} 
	} 
	if (pattern_index == pattern_length) 
	{
		return target_index - pattern_index; 
	}
	else 
	{ 
		return -1; 
	} 
	delete[] overlay_value; 
}