KMP算法详解

  在文本编辑中,我们经常要在一段文本中某个特定的位置找出 某个特定的字符或模式。 由此,便产生了字符串的匹配问题。 首先,我们从简单的字符串匹配算法开始,再到KMP算法,由浅入深,教你从头到尾彻底理解KMP算法。

1.BF算法

  BF算法,即暴风(Brute Force)算法,是普通的模式匹配算法,BF算法的思想就是将目标串S的第一个字符与模式串T的第一个字符进行匹配,若相等,则继续比较S的第二个字符和 T的第二个字符;若不相等,则比较S的第二个字符和T的第一个字符,依次比较下去,直到得出最后的匹配结果。BF算法是一种蛮力算法。

#include<iostream>
#include<string>
using namespace std;

int match(const string& target, const string& pattern) {
	int target_length = target.size();        //目的字串
	int pattern_length = pattern.size();      //模式
	int target_index = 0; int pattern_index = 0; 

	while (target_index < target_length && pattern_index < pattern_length) 
	{ 
		if (target[target_index] == pattern[pattern_index]) 
		{ 
			++target_index; 
			++pattern_index; 
		} 
		else
		{ 
			target_index = target_index-pattern_index + 1;   //目的字串回退到原来开始匹配的位置+1,即现在失配的位置减去模式串已经匹配的位置+1
			pattern_index = 0;                     //模式子串回退到0
		} 
	} 

	if (pattern_index == pattern_length) 
	{ 
		return target_index - pattern_length; 
	}
	else
	{ 
		return -1; 
	}
}

int main()
{
	cout << match("banananobano", "nano") << endl;
	return 0;
}

在这里插入图片描述
  分析;在最坏情况下,此简单模式匹配算法的运行时间为O((n-m+1)m)。
  我们主要把时间浪费在什么地方呢, 观查index = 2那一步,我们已经匹配了3个字符,而第4个字符是不匹配的,这时我们已经匹配的字符序列是nan, 此时如果向右移动一位,那么nan最先匹配的字符序列将是an,这肯定是不能匹配的, 之后再右移一位,匹配的是nan最先匹配的序列是n,这是可以匹配的。
  如果我们事先知道pattern本身的这些信息就不用每次匹配失败后都把target_index回退回去, 这种回退就浪费了很多不必要的时间,如果能事先计算出pattern本身的这些性质, 那么就可以在失配时直接把pattern移动到下一个可能的位置, 把其中根本不可能匹配的过程省略掉, 如上表所示我们在index=2时失配,此时就可以直接把pattern移动到index=4的状态, kmp算法就是从此出发。

2.KMP算法

2.1、 覆盖函数(overlay_function)
  覆盖函数所表征的是pattern本身的性质,可以让为其表征的是pattern从左开始的所有连续子串的自我覆盖程度。 比如如下的字串,abaabcaba
在这里插入图片描述
  由于计数是从0始的,因此覆盖函数的值为0说明有1个匹配,对于从0还是从1开始计数是偏好问题, 具体请自行调整,其中-1表示没有覆盖,那么何为覆盖呢,下面比较数学的来看一下定义,比如对于序列
         a0a1…aj-1aj
  要找到一个k,使它满足
         a0a1…ak-1ak = aj-kaj-k+1…aj-1aj
而没有更大的k满足这个条件,就是说要找到尽可能大k,使pattern前k字符与后k字符相匹配,k要尽可能的大, 原因是如果有比较大的k存在,而我们选择较小的满足条件的k, 那么当失配时,我们就会使pattern向右移动的位置变大,而较少的移动位置是存在匹配的,这样我们就会把可能匹配的结果丢失。
  计算这个overlay函数的方法可以采用递推,可以想象如果对于pattern的前j个字符,如果覆盖函数值为k
         a0a1…ak-1ak = aj-kaj-k+1…aj-1aj
则对于pattern的前j+1序列字符,则有如下可能
⑴ pattern[k+1]==pattern[j+1] 此时overlay(j+1)=k+1=overlay(j)+1,(表示下一个字符也匹配)
⑵ pattern[k+1]≠pattern[j+1] 此时只能在pattern前k+1个子符组所的子串中找到相应的overlay函数,h=overlay(k),如果此时pattern[h+1]==pattern[j+1],则overlay(j+1)=h+1否则重复(2)过程.

//模式串的覆盖数组
void compute_overlay(const string& pattern) 
{
	const int pattern_length = pattern.size(); 
	int *overlay_function = new int[pattern_length]; 
	int index; 
	overlay_function[0] = -1;  //初始化为-1
	for (int i = 1; i<pattern_length; ++i)
	{
		index = overlay_function[i - 1];   //将先前的失败位置k存储为索引
		while(index>=0 && pattern[i]!=pattern[index+1]) 
		{ 
			index = overlay_function[index]; 
		} 
		if(pattern[i]==pattern[index+1]) 
		{
			overlay_function[i] = index + 1;
		}
		else 
		{ 
			overlay_function[i] = -1; 
		} 
	} 

	for(int i=0;i<pattern_length;++i)
	{ 
		cout<<overlay_function[i]<<" "; 
	}
	cout << endl;

	delete[] overlay_function;
}

int main()
{
	string pattern = "abaabcaba";   //-1,-1,0,0,1,-1,0,1,2
	//cout << match("banananobano", "nano") << endl;
	compute_overlay(pattern);
	return 0;
}

在这里插入图片描述
在这里插入图片描述
2.2、kmp算法
  有了覆盖函数,那么实现kmp算法就是很简单的了,我们的原则还是从左向右匹配,但是当失配发生时,我们不用把target_index向回移动,target_index前面已经匹配过的部分在pattern自身就能体现出来,只要动pattern_index就可以了。
  当发生在j长度失配时,只要把pattern向右移动j-overlay(j)长度就可以了。如果失配时pattern_index==0,相当于pattern第一个字符就不匹配, 这时就应该把target_index加1,向右移动1位就可以了。

//模式串的覆盖数组
void compute_overlay(const string& pattern, int* &overlay_function)
{
	const int pattern_length = pattern.size(); 
	int index; 
	overlay_function[0] = -1;  //初始化为-1
	for (int i = 1; i<pattern_length; ++i)
	{
		index = overlay_function[i - 1];    //将先前的失配位置k存储为索引
		while(index>=0 && pattern[i]!=pattern[index+1]) 
		{ 
			index = overlay_function[index];   //失配则开始回退,index记录回退的位置
		} 
		if(pattern[i]==pattern[index+1])     //字符串相匹配
		{
			overlay_function[i] = index + 1;
		}
		else       //index < 0
		{ 
			overlay_function[i] = -1; 
		} 
	} 
}

int kmp_find(const string& target, const string& pattern) 
{
	const int target_length = target.size(); 
	const int pattern_length = pattern.size(); 
	int * overlay_value = new int[pattern_length]; 
	
	compute_overlay(pattern, overlay_value);

	int pattern_index = 0; 
	int target_index = 0; 

	while (pattern_index<pattern_length && target_index<target_length) 
	{ 
		if (target[target_index] == pattern[pattern_index]) 
		{ 
			++target_index; 
			++pattern_index; 
		} 
		else if (pattern_index == 0) 
		{ 
			++target_index;
		} 
		else
		{ 
			pattern_index = overlay_value[pattern_index - 1] + 1;
		} 
	} 
	if (pattern_index == pattern_length) 
	{
		return target_index - pattern_index; 
	}
	else 
	{ 
		return -1; 
	} 
	delete[] overlay_value; 
} 

在这里插入图片描述

<think>好的,用户想要了解KMP算法的详细解释和使用方法,包括实现步骤和示例代码。我需要根据提供的引用资料来整理回答。首先,KMP算法的核心思想是通过预处理模式串生成next数组,避免回溯主串指针,提高匹配效率。接下来,我需要分步骤解释算法流程,比如如何构建next数组,如何进行匹配过程。然后,给出一个具体的示例代码,可能用Python来实现,因为用户之前的示例也是Python。还要注意用户提到的系统级指令,比如数学公式的格式,独立公式用$$...$$,行内用$...$。同时,回答中需要自然地添加引用标识,比如在提到优化效率时引用[^2]。最后,生成相关问题,比如next数组的构建方法、时间复杂度分析等。需要确保LaTeX语法正确,比如模式串的前缀函数可能用数学表达式表示。检查是否有遗漏的步骤,比如部分匹配表的生成过程,确保逻辑清晰,结构合理。</think>### KMP算法详解及实现 #### 一、核心思想 KMP算法通过**前缀函数**预处理模式串生成$next$数组,使得匹配失败时能跳过无效比较。其核心是保持主串指针$i$不回溯,仅调整模式串指针$j$,将时间复杂度从暴力算法的$O(n \times m)$优化到$O(n + m)$[^3]。 #### 二、实现步骤 1. **构建next数组** - 定义:$next[j]$表示模式串$P[0..j]$中最长相等前后缀长度 - 递推公式: $$ next[j] = \begin{cases} -1 & j=0 \\ max\{k \mid 0 \leq k<j \text{ 且 } P[0..k] = P[j-k..j]\} & \text{其他情况} \end{cases} $$ - 示例:模式串"ABABC"的$next$数组为$[-1,0,0,1,2]$ 2. **匹配过程** - 初始化$i=0$, $j=0$ - 当$i < \text{主串长度}$且$j < \text{模式串长度}$: - 若$j=-1$或主串$T[i] = P[j]$,则$i++, j++$ - 否则$j = next[j]$ - 当$j \geq \text{模式串长度}$时匹配成功 #### 三、Python实现示例 ```python def kmp(text, pattern): n, m = len(text), len(pattern) next_arr = get_next(pattern) i = j = 0 while i < n and j < m: if j == -1 or text[i] == pattern[j]: i += 1 j += 1 else: j = next_arr[j] return i - j if j == m else -1 def get_next(pattern): m = len(pattern) next_arr = [-1] * m k = -1 for j in range(1, m): while k >= 0 and pattern[j] != pattern[k+1]: k = next_arr[k] if pattern[j] == pattern[k+1]: k += 1 next_arr[j] = k return next_arr ``` #### 四、示例说明 主串$T= "ABABABABC"$,模式串$P= "ABABC"$时: 1. 生成$next=[-1,0,0,1,2]$ 2. 匹配失败时通过$next$数组跳过冗余比较 3. 最终在第4次调整后匹配成功[^1]
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值