详解BF算法和KMP算法

1.前言 

对于字符串匹配问题，即在一个字符串中查找另一个字符串是否存在，通常有两种匹配算法。

一种是暴力求解，BF算法；另一种是KMP算法。

2.BF算法

所谓暴力求解，就是两个下标分别从主串和子串的0下标位置开始，比较下标对应的字符

如果相等，则两个下标都++

如果不相等，则主串的下标回到起始位置的下一个位置，子串回到起始位置

如果子串先走完了，则表明找到了，返回子串第一个元素在主串中的位置；

如果主串走完了，还没返回，表明找不到；返回-1。

假设主串长度为m，子串长度为n

时间复杂度：O(m*n)

代码的实现：

int BF(const char* Str, const char* Sub)
{
	assert(Str != NULL && Sub != NULL);

	int lenStr = strlen(Str);
	int lenSub = strlen(Sub);

	if (lenStr < lenSub)
		return -1;

	int i = 0;//遍历主串
	int j = 0;//遍历子串
	while (i < lenStr)
	{
		if (Str[i] == Sub[j])
		{
			i++;
			j++;
		}
		else
		{
			i = i - j + 1;
			j = 0;
		}

		if (j == lenSub)
			return i - j;
	}

	return -1;
}

2.KMP算法

kmp算法是由Knuth，Morris，Pratt发现的，相较于BF算法，它更高效，高效在什么地方呢？

BF算法中匹配失败时，i回退到起始位置的下一个位置，j回退到起始位置

而在KMP算法中，i不用回退

由于i和j能走到当前的位置，说明它们前面的某部分是相匹配的，因此j也不用回退到起始位置，而是回退到某一特定的位置，而怎么计算特定的位置就是KMP算法的关键。

2.1next数组

这边我们引入next数组的概念，它用来记录当匹配失败时，子串下标应当回到的某一特定的位置

并规定，子串第一个元素和第二个元素回到的位置是-1和0

next数组的手动计算：

假设有这样的一对字符串，走到了匹配失败的字符

怎么确定j返回的位置？

我们的目的是保持i不变，j回退到某一特定的位置，希望主串中有部分能跟子串匹配，这是肯定有的，因为i和j能走到当前位置，就表明前面有部分字符串是匹配的。

我们发现子串0~1和3~4之间字符串和主串的3~4字符串相等，且字符串的长度为2，因此j要返回的位置就是2位置，即next[j] = 2。

为什么回退的位置就是2，我们后面会给出证明，这里暂时先知道结论。

因此next[j]的计算方法就是：

在0~j-1的字符串中，如果有两个字符串，其中一个字符串以0位置的字符开始，另一个字符串以j-1位置的字符结束，且两个字符串相等，则字符串的长度就是j返回的位置。

下面给出一些练习，手动求一下子串的next数组：

1.求"ababcabcdabcde"的next数组
2.求"abcabcabcabcdabcde"的next数组 

 知道了怎么手动求next数组，代码该怎么实现呢？

假设我们已经知道了next[j]=k，怎么求next[j+1]？

此时分两种情况：

1)Sub[j] = Sub[k]：

 得出结论就是next[i+1] = k+1

2)Sub[j] != Sub[k]

基础代码：

int KMP(const char* Str, const char* Sub)
{
	assert(Str != NULL && Sub != NULL);

	int lenStr = strlen(Str);
	int lenSub = strlen(Sub);

	if (lenStr < lenSub)
		return -1;

	int i = 0;//遍历主串
	int j = 0;//遍历子串

	int* next = (int*)malloc(sizeof(int) * lenSub);
	GetNext(Sub, next, lenSub);

	while (i < lenStr)
	{
		if (j == -1 || Str[i] == Sub[j])
		{
			i++;
			j++;
		}
		else
		{
			j = next[j];//j回退
		}

		if (j == lenSub)
			return i - j;
	}

	return -1;
}

这里需要解释的是为什么要加上j==-1这个判断条件

有这样一种情况，一直往后退，直到j==-1了，还是没有Str[i] == Sub[j]

此时进行判断会发生数组的越界访问

而j++刚好等于0，i++往后走，符合我们的要求

 接下来就剩next数组了

上面的前提条件是知道了next[j]=k，当Sub[j]=Sub[k]时，可以得出next[i+1]=k+1

而此时我们并不知道next[j]的值，该怎么办呢？

可以利用上一个位置的值，我们是知道上一个位置的值的

即next[j-1]=k，此时若Sub[j-1]=Sub[k]，则Sub[j]=k+1

void GetNext(const char* Sub, int* next, int lenSub)
{
	assert(Sub != NULL);

	next[0] = -1;
	if (lenSub == 1)
		return;

	next[1] = 0;

	int j = 2;
	int k = 0;

	while (j < lenSub)
	{
		if (k == -1 || Sub[j - 1] == Sub[k])
		{
			next[j] = k + 1;
			j++;
			k++;
		}
		else
		{
			k = next[k];
		}
	}
}

有这样的情况：Sub[j-1] != Sub[k]，k一直回退到了k==-1

进行判断会发生数组越界访问所以if判断加上k==-1的条件

总的代码如下：

void GetNext(const char* Sub, int* next, int lenSub)
{
	assert(Sub != NULL);

	next[0] = -1;
	if (lenSub == 1)
		return;

	next[1] = 0;

	int j = 2;
	int k = 0;

	while (j < lenSub)
	{
		if (k == -1 || Sub[j - 1] == Sub[k])
		{
			next[j] = k + 1;
			j++;
			k++;
		}
		else
		{
			k = next[k];
		}
	}
}

int KMP(const char* Str, const char* Sub)
{
	assert(Str != NULL && Sub != NULL);

	int lenStr = strlen(Str);
	int lenSub = strlen(Sub);

	if (lenStr < lenSub)
		return -1;

	int i = 0;//遍历主串
	int j = 0;//遍历子串

	int* next = (int*)malloc(sizeof(int) * lenSub);
	GetNext(Sub, next, lenSub);

	while (i < lenStr)
	{
		if (j == -1 || Str[i] == Sub[j])
		{
			i++;
			j++;
		}
		else
		{
			j = next[j];//j回退
		}

		if (j == lenSub)
			return i - j;
	}

	return -1;
}

2.2next数组的优化

我们的next数组是可以优化的

在这样的情景下

当在j位置匹配成功时，j++，无事发生

而匹配失败时，j回到1位置，而Sub[1]==Sub[j]，此时肯定也是匹配不上的，那这一步回退就是多余的

所以当Sub[j] = Sub[k]时，next[j] = next[k]

void NextOptimize(const char* Sub, int* next, int lenSub)
{
	assert(Sub != NULL);

	int i = 2;
	while (i < lenSub)
	{
		if (Sub[i] == Sub[next[i]])
		{
			next[i] = next[next[i]];
		}
		i++;
	}
}

总的代码：

void GetNext(const char* Sub, int* next, int lenSub)
{
	assert(Sub != NULL);

	next[0] = -1;
	if (lenSub == 1)
		return;

	next[1] = 0;

	int j = 2;
	int k = 0;

	while (j < lenSub)
	{
		if (k == -1 || Sub[j - 1] == Sub[k])
		{
			next[j] = k + 1;
			j++;
			k++;
		}
		else
		{
			k = next[k];
		}
	}

}

void NextOptimize(const char* Sub, int* next, int lenSub)
{
	assert(Sub != NULL);

	int i = 2;
	while (i < lenSub)
	{
		if (Sub[i] == Sub[next[i]])
		{
			next[i] = next[next[i]];
		}
		i++;
	}
}

int KMP(const char* Str, const char* Sub)
{
	assert(Str != NULL && Sub != NULL);

	int lenStr = strlen(Str);
	int lenSub = strlen(Sub);

	if (lenStr < lenSub)
		return -1;

	int i = 0;//遍历主串
	int j = 0;//遍历子串

	int* next = (int*)malloc(sizeof(int) * lenSub);
	if (next == NULL)
	{
		perror("next");
		return -1;
	}
	GetNext(Sub, next, lenSub);
	NextOptimize(Sub, next, lenSub);

	while (i < lenStr && j <lenSub)
	{
		if (j == -1 || Str[i] == Sub[j])
		{
			i++;
			j++;
		}
		else
		{
			j = next[j];//j回退
		}
	}

	if (j == lenSub)
	{
		free(next);
		next = NULL;
		return i - j;
	}

	free(next);
	next = NULL;
	return -1;
}

时间复杂度：O(m+n)