KMP模式匹配算法

模式匹配：找到当前字符串中首次与模式字符串完全匹配的位置。

首先讲解暴力搜索算法，KMP匹配算法就是在此基础上发展来的。

代码是基于C语言的。

target指向要搜索的字符串，pattern指向要匹配的模式。

暴力算法简介又称BF算法：

1. 从target的第一个字符开始，依次执行第2步，直到target中剩下的字符个数比pattern中的个数少。
2. 从target当前的字符开始，依次和pattern中的字符匹配，若pattern遍历完全匹配，则函数退出，找到位置。否则执行3。
3. target中的字符后移一位，继续执行1。

下面是代码

// KMP模式匹配.cpp : 定义控制台应用程序的入口点。
//

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

bool Match(const char *target,const char *pattern,int& pos)
{
	int i,j,k;
	
	for (i=0 ; i<=strlen(target)-strlen(pattern) ; i++)
	{
		for (j=0 ; j<strlen(pattern) ; j++)
		{
			if (*(target+i+j)!=*(pattern+j))
				break;
		}
		if (j>=strlen(pattern))
		{
			pos=i+1;
			return true;
		}
	}

	return false;
}


int main(void)
{
	char *a="goodgoogle";
	char *b="google";
	int pos=0;
	if (Match(a,b,pos))
	{
		printf("pos=%d\n",pos);
	}
	return 0;
}

KMP模式匹配。

在暴力算法中可能会出现重复的情况，例如：

目标串：      annabcdanacadsannannabnna

 模板串：     annan

在标注红字的地方首次失配，在暴力算法中，下次匹配从目标串的第二个字符开始，再重新对模板串进行匹配：

目标串：      annabcdanacadsannannabnna

 模板串：       annan

但是我们发现模板串是有一定性质的。即首尾有重复的字符。失配前的字符'a'和模板的首字符'a'相同，下次可以直接将首字符对准失配前的字符，从当前失配的字符'b'开始匹配。这样目标串中的字符每个只检查了一次，减少了重复匹配，如果模板串，在失配的字符前有n个字符是首尾相同的，那么在失配后，就可以直接将模板的前n个字符和目标串失配字符前对准，从失配的字符开始下一轮匹配。

目标串：      annabcdanacadsannannabnna

 模板串：           annan

这就是KMP算法的精髓。可以看出来，首先要确定“模板串，在失配的字符前有n个字符是首尾相同的”。关键是模板的性质。

“annan”，如果在第一位失配，这个比较特殊，没有首尾。

                如果在第二位失配，这个比较特殊，没有首尾。

                如果在第三位失配，首尾相同的字符有0个。

               如果在第四位失配，首尾相同的字符有1个。

               如果在第五位失配，首尾相同的字符有2个。

这样就可以建立一个索引数组

index[]={0,0,0,1,2};除j=0时失配外，当模板的第j位失配时，下一次就从模板的index[j-1]位开始匹配（字符串从0位开始），目标串直接从当前失配的位置开始。

如果是j=0就失配，那么下一轮模板直接从j=0开始，目标串从下一位开始。

这是KMP匹配算法的代码

bool KmpMatch(const char *target,const char *pattern,int& pos)
{
	if (!target||!pattern)
		return false;

	int *index=(int*)malloc(sizeof(int)*strlen(pattern));
	if (!index)
		exit(-1);

	GetIndexNew(pattern,index);
	
	int i=0,j=0;
	for (i=0 ; i<=strlen(target)-(strlen(pattern)-j) ; )
	{
		while (j<strlen(pattern))
		{
			if (target[i]==pattern[j])
			{
				i++;
				j++;
			}
			else
			{
				if (j==0)
					i++;
				else
					j=index[j-1];
				break;					
			}			
		}
		if (j>=strlen(pattern))
		{
			pos=i-j+1;
			return true;
		}
	}
	return false;
}

写的有点罗嗦，等看了其他人的代码再优化。

下面是写出index数组的算法。

index数组一共有n位，第0位肯定为0；

假设当前在计算第i（i>0）位，之前的0～i-1位都是计算好的。那么i-1位就是保存着模板串中0～i-1位有几个数字是首尾相同的。

直接比较第i位，和第index[i-1]位，如果相同，那么index[i]=index[i-1]+1，如果不同，那么就从新比较模板中第i位和第0位，相同index[i]=1，不同index[i]=0。

那么可以写出代码：

void GetIndexNew(const char *pattern,int *index)
{
	int i;
	index[0]=0;
	for (i=1;i<strlen(pattern);i++)
	{
		if (pattern[i] == pattern[ index[i-1] ])
			index[i]=index[i-1]+1;
		else if (pattern[i] == pattern[0])
			index[i]=1;
		else
			index[i]=0;
	}
}

在jully的博客中有详细介绍http://blog.csdn.net/v_july_v/article/details/7041827，我只是按照我的理解做个笔记。