KMP算法

串的模式匹配算法
一.BF算法
1.BF算法基本思想是:从主串S的第1个字符起和模式串T的第一个字符比较，若相等，刚继续逐个比较后续字符;否则从主串的下一个字符起再重新和模式串的字符比较.依次比较下去，直到最后结果

举例说明

S      a    b    a    b     c     a    b    c    a    c    b    a    b
T      a     b   c    a      c
BF算法的匹配的步骤如下(主要说明匹配不成功的情况)
第一趟:(i=0,j=0)
           i = 2
S:a b a b c a b c a c b a b
T:a b c a c
           j = 2

第二趟:(i=1,j=0)
       i = 1
S:a b a b c a b c a c b a b
T:    a b c a c
        j = 1

第三趟:(i=2,j=0)
                        i = 6
S:a b a b c a b c a c b a b
T:       a b c a c
                        j = 4

第四趟:(i=3,j=0)
              i = 3
S:a b a b c a b c a c b a b
T:          a b c a c
              j = 0

第五趟:(i=4,j=0)
                  i = 4
S:a b a b c   a  b   c  a c b a b
T:              a  b  c   a  c
                  j = 0

第六趟:(i=5,j=0)
                                    i = 10
S:a b a b c a b c a c b a b
T:                 a b c a c
                                     j = 5

代码实现

int Index_BF(char *s,char *t)
{
	int sLen = strlen(s);
	int tLen = strlen(t);
	int i=0,j=0;
	while(i < sLen && j < tLen)
	{
		if(s[i]==t[j])
		{
			i++;
			j++;
		}
		else
		{
			i = i - j +1;
			j = 0;
		}
	}
	if(j == tLen)
	{
		return i-j;
	}
	else return -1;
}

二.KMP算法
KMP算法与BF算法的区别就在于KMP算法消除了主串中i的回溯问题，只是需要确定下次匹配j的位置即可,使得问题的复杂度由O(mn) 下降到O(m+n)，在KMP算法中为了确定匹配不成功时，下次匹配时j的位置，引入了next数组，next[j]的值表示T[0...j-1]中最长后缀的长度等于相同字符序列的前缀

对于next[]数组的定义如下
1.next[j] = -1 ; 当j = 0时
2.next[j] = max{k | 0 < k < j 且 T[0...k-1] = T[j-k...j-1] }
3.next[j] = 0;   其它情况

如下例

T:           a       b      a      a      b      c      a      c
 j:           0       1      2      3      4      5      6      7
next     -1        0      0     1      1       2     0      1 

next[j] = k > 0 时 表示T[0...k-1] = T[j-k...j-1]，如j = 5 next[5] = k = 2 时意思即为 T[0...1] = T[3...4]

因此KMP算法的思想就是:在匹配过程中，若发生不匹配的情况，如果next[j] >= 0,则主串的i不变，将模式串j移动到next[j]的位置继续进匹配，若next[j]==-1,i右移一位，并将j置0，继续比较

代码实现如下

int Index_KMP(char *s , char *t)
{
	int next[100]={0};
	int i,j;
	i = 0;
	j = 0;
	get_next(t,next);
	while(i < strlen(s))
	{
		if(j==-1 || s[i]==t[j])
		{
			++i;
			++j;
		}
		else
		{
			j = next[j];
		}
		if(j==strlen(t))
		{
			return i - strlen(t);
		}
	}
	return -1;
}

1.用递推的方法求next函数值
由定义知 next[0] = -1;
设next[j] = k(0 < k < j),则 t[0...k-1] = t[j-k,j-1],
   (1)若t[j] = t[k], 则可得 t[0...k] = t[j-k+1...j],很明显可得next[j+1] = next[j] + 1;
   (2)若t[j] !=t[k], 表时t[0...k] != t[j-k+1...j],此时可以把求next函数值的问题当成一个模式匹配的问题,模式串t即是主串又是模式串,而在当前的匹配中，已知有 t[0] = t[j-k],t[1] = t[j-k+1],t[2] = t[j-k+2],...t[j-1] = t[k-1]... 当t[j]!=t[k]时，应将模式串向右移动，以模式中的next[k]个字符和主串中的第j个字符相比较,

总结以上两种情况
1.t[j]==t[k],next[j+1] = next[j]+1 = k +1;
2.t[j]!=t[k],k = next[k],

代码如下:

void get_next(char *t,int *next)
{
	int j = 0;
	int k = -1;
	next[0] = -1;
	int nLen = strlen(t);
	while(j < nLen-1)
	{
		if(k==-1||t[j]==t[k])
		{
			++j;
			++k;
			next[j] = k;
		}
		else
		{
			k = next[k];
		}
	}
}

2.算法的一点优化，如有模式T:a a a a b,主串S:a a a b a a a a b,当i = 3,j = 3时,s[3]!=t[3](b!=a),由next[j]的指示还需要进行,i=3,j=next[3] = 2,i=3,j=next[2] = 1,i = 3,j = next[1] = 0，三次的比较，这个可以直接和next[1]=0,直接相比较，也就是next[i] = next[j]

代码如下

void get_next(char *t,int *next)
{
	int j = 0;
	int k = -1;
	next[0] = -1;
	int nLen = strlen(t);
	while(j < nLen-1)
	{
		if(k==-1||t[j]==t[k])
		{
			++j;
			++k;
			if(t[j!=t[k]])
			{
				next[j] = k;
			}
			else 
			{
				next[j] = next[k];
			}
		}
		else
		{
			k = next[k];
		}
	}
}

二.直接求next函数值

void _get_next(char *s,int *next)
{
	int i,j,temp;
	for(i = 0 ; i < strlen(s) ; i++)
	{
		if(i==0)
		{
			next[i] = -1;
		}
		else if(i==1)
		{
			next[i] = 0;
		}
		else
		{
			temp = i-1;
			for(j = temp ; j >= 0 ;j--)
			{
				if(equals(s,i,j))
				{
					next[i] = j+1;
					break;
				}
			}
			if(j==-1)
			{
				next[i] = 0;
			}
		}
	}
}

//最大的相同值

bool equals(char *_s,int i,int j)
{
	int k = 0;
	int s = i-j-1;


	for( ;k <= j,s<=i-1 ;k++,s++ )
	{
		if(_s[k]!=_s[s])
		{
			return false;
		}
	}
	return true;
}