KMP算法

关注

原创最新推荐文章于 2026-02-21 08:02:38 发布 290 阅读 AI 写同款· GEO 优化 ›

KMP算法详解文章目录KMP算法前置知识串的基本概念C++C++C++中stringstringstring库的函数KMP核心算法—next数组KMP匹配next数组计算例题KMP算法改进其他字符串知识点计算最长前缀后缀计算循环节补充字符使原字符串变为循环串 KMP算法 KMPKMPKMP算法是字符串匹配中的一个较好的算法，它的目的是在给定一个模式串ppp和原字符串qqq中，找到ppp在qqq中第一次出现的位置。如上图所示，可以很简单的看出字符串ppp在字符串qqq中第一次出现的位置，如果位置从1开始计算的话阅读详情

下面来总结一下用来匹配字符串的KMP算法，以及怎么求next数组。

当然我们可以用笨办法可以进行字符串匹配和求next数组，但是学习算法不就是追求极致的过程么？

通过参考https://blog.youkuaiyun.com/sun20209527/article/details/79933237,可以通透的理解KMP是个什么过程,但细节处理和他会有些出入。

举例来说，有一个字符串"BBC ABCDAB ABCDABCDABDE"，我想知道，里面是否包含另一个字符串"ABCDABD"？

我们先说一下next数组代表的是什么？就是一个字符串的每一个子串的前缀后缀的共有元素长度。

以"ABCDABD"为例，

　　－　"A"的前缀和后缀都为空集，共有元素的长度为0；

　　－　"AB"的前缀为[A]，后缀为[B]，共有元素的长度为0；

　　－　"ABC"的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度0；

　　－　"ABCD"的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为0；

　　－　"ABCDA"的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为"A"，长度为1；

　　－　"ABCDAB"的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为"AB"，长度为2；

　　－　"ABCDABD"的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为0。

所以next[0] = 0 ; next[1] = 1 ; next[2] = 0; next[3] = 0 ; next[4] = 1; next[5] = 2 ; next[6] = 0 ;

下面就是KMP的具体过程：

B与A不匹配，所以搜索词后移一位。

　　因为B与A不匹配，搜索词再往后移。

　　就这样，直到字符串有一个字符，与搜索词的第一个字符相同为止。

这里出现了空格和D不匹配的现象.

注意：这个操作一次连续移动了4位，我们把已经匹配的ABCDAB字符串的前缀移动到后缀的位置上就可以了！

　　因为空格与A不匹配，继续后移一位。

一直匹配。。。。一直到发现C和D不匹配。

已经匹配的字符串ABCDAB还是把最大的前缀放到后缀的位置上。然后继续匹配ABCDAB后面的字符。

　　"部分匹配"的实质是，有时候，字符串头部和尾部会有重复。比如，"ABCDAB"之中有两个"AB"，那么我们可以利用next数组记录的信息搜移动之后，就可以来到第二个"AB"的位置。

#include<iostream>
#include<cstring>
using namespace std;
void getnext(string s,int next[])
{
	int n = s.size();	
	memset(next,0,sizeof(next));
	int k = 0;                      //k代表 最大前后缀长度 
	for(int i = 1,k = 0; i<n; i++)
	{
		while(k>0 && s[k] != s[i])
		{
			k = next[k-1];	
		} 
		
		if(s[i] == s[k])
		{
			k++;
		}
		next[i] = k;
	}

	
}
 //a 是主字符串   b是小字符串 
int kmp(string a,string b,int next[])
{
	
	int n = a.size() , i = 0;           //主字符串的长度，主字符串的下标 
	int m = b.size() , j = 0;			//小字符串的长度，已经匹配的个数 
	
	while(i < n) 
	{
		
		if(j==0)                       //如果小字符串中的第一个元素没有找到与大字符串中有匹配的，那就寻找===  
		{
			if(a[i] == b[j])
			{
				j++;                                      //已经匹配的个数 
			}
			else
			{
				i++;									 //主字符串的 下标 
			}
		}else{                        //已经有匹配的了 
			if(a[i+1] != b[j])    //如果不下一个字符不相等，那就移动小字符串，这个过程操作起来就是更改小字符串的下标。 
			{
				j = next[j-1];
			}	
		
			if(a[i+1] == b[j])  //如果相等那就比较下一个字符 
			{
				i++;
				j++;
				
			 }
	}
		
	    if(j == m)                    //如果小字符串全比较完了，那就是全匹配了，完成！ 否则大字符串中不存在 小字符串！ 
			return i;                //这里返回小字符串在大字符串中最后匹配成功的字符的下标 
	}
	return 0;	
}

int main()
{
	int next[1000];
	string a = "BBC ABCDAB ABCDABCDABDE";

	string b = "ABCDABD";
	
	getNext(next,b);
	

	cout<<"kmp:"<<kmp(a,b,next)<<endl;	
}

这里的求next数组我们可以用笨办法枚举的方法如下：

void getNext(int next[],string s)
{
	memset(next,0,sizeof(next));
	for(int i=0; i<s.size(); i++)
	{
		int ans = 0;
		
		string str = s.substr(0,i+1);
		for(int j=0; j<str.size()-1; j++)
		{
			string str1 = str.substr(0,j+1);			
			string str2 = str.substr(str.size()-j-1,str.size());
			if(str1==str2)
			{
				ans = j+1;
			}
		
		}
		
		next[i] = ans;
	}
}

这样很容易懂，和容易写出来，但是效率很慢！所以在网上找到了一个特别精简的方法！

void getnext(string s,int next[])
{
	int n = s.size();
	memset(next,0,sizeof(next));
	int k = 0;                                  //k代表 最大前后缀长度 
	for(int i = 1,k = 0; i<n; i++)
	{
		while(k>0 && s[k] != s[i])             //精髓！！！！
		{
			k = next[k-1];	
		} 
		
		if(s[i] == s[k])
		{
			k++;
		}
		next[i] = k;
	}

	
}

k代表的是前一个字符串最长的前后缀长度； a[i]是新加上的字符

这里分几种情况：

1、如果s[0]......s[k-1]和s[i-k].......s[i-1]匹配，并且s[i] == s[k] ，那么next[i] = next[i-1]+1就可以了（简单的情况）

2、但是如果s[i] != s[k]呢？就是上面的标记精简的那段代码！

我们应该利用已经得到的next[0]···next[k-1]来求s[0]···s[k-1]这个子串中最大相同前后缀。因为！！在于s[k]已经和s[i]失配了，而且s[i-k] ··· s[i-1]又与s[0] ···s[k-1]相同，看来s[0]···s[k-1]这么长的子串是用不了了，那么我要找个同样也是s[0]打头、s[k-1]结尾的子串即s[0]···s[j-1](j==next[k-1])，看看它的下一项s[j]是否能和s[i]匹配。

用我们一个例子把：

ABADABA[B]

我们已经知道了 ABADABA的 next[6] = 3，也就是k=3，但是s[3]=D不等于s[7]=B，k= next[k-1] = next[2] = 1,再来比较s[1]和s[i],结果相等，那么next[7]=next[1]+1 = 2;

收录于