直观清晰的带你了解KMP算法(超详细)

KMP算法用来找某个字符串是否存在某个连续的真子串的

下面举一个例子让抽象的KMP算法更加直观，有助于理解

首先我们要了解KMP算法首先要找到一个next数组来表示主串中每一个字符的回退的下标（这个下标是对于真子串而言的，主串不需要回退）（这可能看的很懵逼，但是不要紧，接着往下看你肯定明白了）

例：寻找字符串”abcaefabcdabsd"的子串abcd

寻找字符串”a   b  c    a e  f  a  b  c d a  b  s  d"的子串abcd(这里我把题目字符串拉的很开便于大家理解）
     主串p[i]   a     b   c   a    e   f   a    b    c     d     a     b    s    d
                    
主串不回退，子串回退
                            0     1   2   3    4   5  6    7    8    9     10   11  12  13
                            a     b   c   a    e   f   a    b    c     d     a     b    s    d
（所有从字符串必须从a开始p[i-1]字符结束的相同字符串，而且两个子字符串必须相同。
我们记a的回退下标为-1，那么从字符b开始，准备开始寻找从a字符开始，从p[i]字符前一个字符结束的相同的字符串是否有两个，单一的字符也算
我们可以看到从b字符下标应该是0，因为从a字符开始，从a字符结束的字符串只有1个，那就是a字符，所以b下标是0
同理我们看第三个字符c就是从a字符开始，b字符结束的字符串是否存在两个，很显然是没有的，所以c的下标是0
同理第四个字符也是0
从第五个字符就不一样了，从a开始从e结束相同的字符串没有
我们看第八个字符，前面一个字符以a开始b结束的相同字符串是否有两个，我们可以找到两个（我做红色标记的），（必须a为首，b为尾巴，找到两个相同的字符串），而且这两个相同的字符串的长度为2所以我们把字符c的下标记为2，后面就同理了
 0     1   2   3    4   5  6    7    8    9     10   11  12  13
 a     b   c   a    e   f   a    b    c     d     a     b    s    d

  主串        p[i]      0     1   2   3    4   5  6    7    8    9    10  11  12  13
                            a     b   c   a    e   f   a    b    c    d     a     b    s    d

 回退数组next    -1    0   0   0    0   0   0    1    2    3     0     1    0    0

             子串s[j]   a    b   c   d
 这个回退是针对子串而言的，我们定义i为主串下标，j为子串下标

 i从0开始遍历，j也从0开始，第一个都是a，都往后走i++,j++，然后到第4个字符发现不一样，那么怎么办呢？这个时候就开始用到了next数组了，next[j]赋给j，也就是回退到子串的最开始的字符s[0]，因为主串中的第四个字符a对于的next数组下标为0，然后此时的j=-1，怎么办数组越界了，这个时候我们需要把-1回正为0，又可以从子串的第一个字符开始遍历了，直到主串中第7个字符，对于的next数组下标为1 ，我们对于的子串需要回退到下标为1的字符，也就是s[1]，然后继续进行到主串第9个字符对于的next数组下标为3，这时把子串回退到s[3]，也就是字符d，又开始遍历到第10个字符a，发现前面一个字符9正好就是对应子串最后一个字符，所以我们要返回找到的子串在主串的下标位置，也就是i-j，为什么呢？你看这时的i是10，j是4，对应的返回值是6不就是主串中第6个字符a开始，到第9个字符d就是子串吗？

上面字面意思理解了的话我们开始设计程序了

问题1：如何设计next数组

问题2：子串的字符怎么设计程序回退呢？

下面解决问题1：如何设计next数组

首先如果我们已经直到next[0]=-1,next[1]=0,怎么推next[2]呢？

解析如下：

  主串        p[i]      0     1   2   3    4   5  6    7    8    9    10  11  12  13
                            a     b   c   a    e   f   a    b    c    d     a     b    s    d

 回退数组next    -1     0   0   0    0   0   0    1    2    3     0     1    0    0

 代表回退数组的对应的数字

 我们先假设主串遍历到了第九个字符，但是我不知道第9个字符对应的next数组的数字，我   们的第8个字符的上标为8，然后对应的k是2，这里的p[2]是c，说明p[2]和p[8]相等啊，那么

p[9]的下标怎么求呢？next[9]=2+1,你们看对不对

然后再举个例子：

如果我们要找p[10]的下标呢？同上，先看p[9]的下标为3，对吧，我们看p[9]和p[3]，发现根本不相等，怎么办呢？那么我们就从p[3]对应的next值入手，p[3]对应的next值为0，我们再回退到0，发现第p[0]与p[10]相等，这里p[0]的next的值就是对应的p[10]next值+1啦！

下面总结：

我们能不能发现一个规律，如果          p[i-1]==p[k]  那么就有next[i]=k+1

如果不相等，就是不断回退，如果回退到第一个字符还是不相等那么此时对应的下标就是0

问题2：子串的字符怎么设计程序回退呢？

代码如下：k=next，就是字符不相等的时候回退上一个对应next值的主串上标的字符。

//str代表主串
//sub代表子串
//pos代表主串开始移动的位置
//我们定义主串第一个字符下标为-1，第二个就为0
//len是主串的长度
void Getnext(char* str, int* next, int len)
{
	next[0] = -1;;//我们定义主串第一个字符对应的next数组第一个元素为-1
	next[1] = 0;//第二个就为0
	//从第三个开始找next数组的规律
	int i = 2;//第三个元素的标号
	int k = 0;
	while (i < len)
	{
		if (k==-1||str[i - 1] == str[k])
		{
			next[i] = k + 1;
			i++;
			k++;
		}
		else
		{
			k = next[k];
		}
	}
}

核心知识点就上面这些了，如果看明白的话，大家先根据自己的理解设计一下，下面就是源码了，有注释

#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
#include
#include
//str代表主串
//sub代表子串
//pos代表主串开始移动的位置
//我们定义主串第一个字符下标为-1，第二个就为0
void Getnext(char* str, int* next, int len)
{
	next[0] = -1;;//我们定义主串第一个字符对应的next数组第一个元素为-1
	next[1] = 0;//第二个就为0
	//从第三个开始找next数组的规律
	int i = 2;//第三个元素的标号
	int k = 0;
	while (i < len)
	{
		if (k==-1||str[i - 1] == str[k])
		{
			next[i] = k + 1;
			i++;
			k++;
		}
		else
		{
			k = next[k];
		}
	}
}
int KMP(char* str,char* sub,int pos)
{
	assert(str&&sub);
	int i = pos;//遍历主串
	int j = 0;//遍历子串
	int lenstr = strlen(str);
	int lensub = strlen(sub);
	//此时都空的字符串
	if (lenstr == 0 || lenstr == 0) return -1;
	//此时如果遍历主串的pos<0或者大于等于主串长度，也是返回-1
	if (pos < 0 || pos >= lenstr) return -1;
	int* next = (int*)malloc(lenstr * sizeof(int));//主串的元素个数和next数组相同
	assert(next);
	Getnext(str,next,lenstr);
	while(i= lensub)
		return i - j;//返回主串找到子串第一个字符的下标
	//如果没有找到返回0
	return 0;
}
int main()
{
	printf("%d", KMP("abdaabc","abc",0));
	return 0;
}

上面代码的next数组还有优化空间：

不断回退的次数，我们怎么改成一次性回退呢？

下面我们来设计nextval数组

void Getnext(char* str, int* next, int* nextval,int len)
{
	next[0] = -1;;//我们定义主串第一个字符对应的next数组第一个元素为-1
	next[1] = 0;//第二个就为0
	//从第三个开始找next数组的规律
	int i = 2;//第三个元素的标号
	int k = 0;
	while (i < len)
	{
		if (k==-1||str[i - 1] == str[k])
		{
			next[i] = k + 1;
			i++;
			k++;
		}
		else
		{
			k = next[k];
		}
	}
	//开始设计nextval数组
	i = 2;
	nextval[0] = -1;
	nextval[1] = 0;
	while (i < len)
	{
		//相同的话就回退到那一个nextval的值
		if (str[i] == str[next[i]])
		{
			nextval[i] = next[next[i]]; 
			i++;
		}
		//不同的话，就等于next的值
		else
		{
			nextval[i] = next[i];
			i++;
		}
	}
}

最后补充一些KMP算法的时间复杂度O(M+N)

M是主串的长度，N是子串的长度

BF算法的时间复杂度是O(M*N)