kmp算法
前言: 如何匹配字符串???
如对于以下两个字符串：
char *str = "bacbababadababacambabacaddababacasdsd";
char *ptr = "ababaca";
如何判断 str 串中是否有 ptr 串?? 如果有, 请给出匹配到的字符串的下标.
通常而言，进行字符串匹配有两种做法：
- 暴力法
- KMP 法
一. 暴力匹配字符串
1.1 暴力算法描述
暴力法步骤如下:
- 从目标字符串str 的 i (第一次为首元素) 起 截取ptr长度(长度为m) 的子字符串进行比较
- 如果一样，就返回匹配到的子串的下标值.
- 不一样，i = i+1 .(且 ptr 指针回退到 0 (即令 j == 0)).
- 重复1,2,3 直到str的末尾（实际比较时，下标移动到n-m）。这样的时间复杂度是O(n*m)。
1.2 暴力算法实现
int volence(const char* str, int str_len, const char* ptr, int ptr_len)
{
int i = 0;
int j = 0;
while(i < str_len && j < ptr_len)
{
if(str[i] == ptr[j])//匹配相等则继续
{
++i;
++j;
}
else
{
i = i - j + 1;
//比对失败, 说明从 i 开始的串匹配失败,
//所以要向右移动一位到 i+1 位再进行匹配
//又因为和错误的串匹配已经前进了j个单位,所以要 - j 个单位.
j = 0;// p 串匹配失败了, 要从头开始匹配故置0
}
}
if(j == ptr_len)//代表匹配上了
{
return i - j;//i 代表已经匹配上的串的末尾的下一个, 减去长度 j 即可得到串首的下标
}
return -1;
}
二. KMP算法 匹配字符串
我们可以发现, 暴力法匹配字符串有着显而易见的缺点:
匹配失败时每次向后移动一个单位, 再继续匹配, 而且模式串 Ptr 需要置为 0.
那么有没有跟快速的算法呢???
kmp 算法出现了.
如图所示:
2.1 三个概念: 最长前缀; 最长后缀; 最长公共前后缀？
以模式串为例
const char* = "ababaca";
列出其所有子串
- 最长前缀： 除了最后一个字符以外的字符串。
- 最长后缀： 除了第一个字符以外的字符串。
- 最长公共前后缀：
看图中红色， 前缀在最长前缀中从前往后找 后缀在最长后缀中从后往前找（ 注意是整体找，不是一个字母一个字母找）
ps: 这里图有错误, 接下里的例子中, 最长公共前后缀的长度从 1 开始而不是从 0 开始.
2.2 滑动多少距离
如图, 紫色部分 的两个元素已经匹配失败了.
这个时候不用像暴力匹配一次移动一个
而是:
将模式串 ptr 从 绿色 的位置移动到 蓝色 的位置即可
可以看出, 要往后移动的距离为
绿色部分的长度 move_size == 红色长度 - 绿色或蓝色部分长度(最长公共前后缀的长度)
然后再继续比较即可.
2.2 回退多少??
滑动操作难以用代码表示, 在实际编程中. 用 j 回退来表示模式串的后移更为方便
即:
往后滑动 一段距离 == j 往前 回退一段同样的距离
如图, 紫色部分 d 与 e 的两个元素已经匹配失败了.
此时,
将 i 保持不变
将 j 回退到 蓝色部分 的第一个字母位置
然后从 j 处继续比对即可.
此方法实际上等价于滑动数组.
回退后的 j 用公式可表示为:
j = j - move_size
=> j = j - (红色长度 - 蓝色长度)
=> j = j - (j - 最长公共前后缀长度)
=> j = 最长公共前后缀长度
2.2 如何得到最长公共前后缀的长度？
所以 kmp 比对的移动依赖于 最长公共前后缀的长度.
以之前举过的模式串为例
const char* = "ababaca";
.
2.1 pm 数组
用 pm 数组 来记录最长公共前后缀的长度
如, 此串的 index 为 0-4
假设已经算出所有的 pm[i].
pm[4] 的值表示从 0 开始到 4 的这个子串: ababa 的最长公共前后缀 的长度 3
所以 pm[4-1] 可以用来表示最长公共前缀的坐标 3.(因为二者长度相等, 且ptr从0开始, i要减1)
推广:
pm[i] 的值表示从 0 开始到 i 的这个子串 的最长公共前后缀 的长度
所以 pm[i-1] 可以用来表示最长公共前缀的坐标.(因为二者长度相等, 且ptr从0开始, i要减1)
当扫描到的只有首元素 a 时, 最长公共前后缀数量一定为 0.
即 i = 0 的时候:
pm[0] = 0;
当扫描到的有 首元素和第二个元素时
若 首元素 等于 第二个元素, 则 最长公共前后缀的数量为 1
即: 比上个串的最长公共前后缀长度 +1
p[1] = pm[0]+1;
我们用 for 循环来表示.
pm[0] = 0;
for(int i = 1; i < str_len; ++i)
{
if(ptr[i] == ptr[next[i-1]])
pm[i] = pm[i-1]+1;
}
若 第二个元素 不等于 首元素, 则最长公共前后缀数量一定为 0.
pm[0] = 0;
for(int i = 1; i < str_len; ++i)
{
if(ptr[i] == ptr[next[i-1]])
pm[i] = pm[i-1]+1;
else
pm[i] = 0;
}
pm[i] 表示最长后缀末尾下标
ptr[pm[i-1]] 表示最长前缀的末尾元素
每当 ( ptr[i] != ptr[next[i-1]] ) 时, 公共前后缀长度 为 0
反之, 则在之前串的 公共前后缀长度上 +1.
2.2 next 数组
前面已经证明了
在遇到 ptr[j] != str[i] 匹配失败时
回退为:
j = 最长公共前后缀长度
可能是论文的编写者觉得太麻烦了, 直接 j = pm[j] 不好吗???
于是乎就将 pm 数组的所有元素全部往右移动了一个单位.
就有了简介的:
j = pm[j]
由于可以直接指出, 下一步 j 回退到哪里, 所以 pm 改名为 next
j = next[j]
由于 右挪, 左边多出来的一位记为 -1, 右边挤掉的一位一定用不到.
代码实现可不是先算出 pm 再往右挪奥, 那样太麻烦.
而是:
void get_next(int* next, const char* ptr, int ptr_len)
{
//将pm中的元素右移一位
next[0] = -1; //第0个元素为-1不作数
next[1] = 0; //第一个元素的公共前后缀必然为 0
for(int i = 2; i < ptr_len; ++i)
{
if(ptr[i - 1] == ptr[next[i - 1]])
//ptr[next[i-1]] 中 next[i-1] 为最长前缀末尾元素的坐标.
//ptr[i-1] 中为当前已经匹配元素的坐标.
//和pm的代码改动只有这里
{
next[i] = next[i - 1] + 1;
}
else
next[i] = 0;
}
for(int i = 0; i < ptr_len; ++i)
cout << next[i] << ' ';
cout << endl;
}
2.2.2 模式串供 1 开始的 next 数组构造
当模式串从 1 开始存储元素时, 比如给 next 数组总体加 1
才能满足 j = next[j]
这里不再多讨论
2.3 KMP 算法步骤描述
通过上述 最长公共前后缀的特性我们可以发现 KMP 的步骤为：
- 从目标字符串str（假设长度为n）的首元素起 截取ptr长度(长度为m) 的子字符串进行比较
- 如果一样，就返回匹配到的子串的下标值.
- 不一样，就将
ptr 第一个匹配失败所在元素的的下标 j , 回退到这个最长公共前后缀后的一位
再同样选取长度为n的字符串进行比较.
(或者可以理解为: ptr整体 滑动到 ptr 的另一个靠后最长公共前后缀处,) - 直到str的末尾（实际比较时，下标移动到n-m）。这样的时间复杂度是O(n+m)。
-------------------------视频讲解: 步骤以及是未匹配的部分移动而不是已经匹配的部分移动
2.3 KMP 算法实现
int kmp_by_using_next(const char* str, int str_len, const char* ptr, int ptr_len, int* next)
{
get_next(next, ptr, ptr_len);
int i = 0;
int j = 0;
while(i < str_len && j < ptr_len)
{
if(str[i] == ptr[j])//匹配上了就继续匹配
{
++i;
++j;
}
else if(j == 0)//两个串的首元素没匹配上, 这个时候若 j == next[j], j 就会被赋值为 -1.
// 所以要特殊处理
//ps: 这里隐含了 str[i] != str[j] && j==0.
//即: str[0] != str[0]
//代表: 如果两个串的第一个元素就不相等, 则应该从主串的第i+1个位置开始,所以++i;
{
++i;
}
else//当匹配失效时,i不变,j 回退next[j]的位置继续比较
{
j = next[j];
//cout << "j:" << j << endl;
}
}
if(j >= ptr_len)//此时i的位置减去匹配串的长度为首次找到的字符串的位置
return i - ptr_len;
return -1;
}
三、 KMP 算法优化 – nextval 数组
3.1 kmp 算法的缺点
思考一下 kmp 的缺点:
以 next 数组作为回退依据.
有时候匹配失效(s[i] != p[j]),
那么 j 回退到 next[j] .
这个 j 我们就用 next[j] 表示.
接下来就是 s[i] 与 p[next[j]] 继续比较.
但是如果回退后的 p[next[j]] 与回退之前的 p[j] 相等.
那就完全没有必要比较啊. 因为
p[j] != s[i];
p[next[j]] == p[i]
等价代换
p[next[j]] 必然 != s[i],
但是 kmp 算法会忠实的做这种无意义的比较,这就是缺点.
3.2 kmp 算法的优化
由缺点得出:
当 p[j] != s[i] 时,
只要 ( p[ next[j] ] == p[j] ),
则 让 j = next[j] 再进行下次比较必然是徒劳的.
所以,
我们要改进 pm 数组为 => pm_val 数组.
从左到右遍历pm数组
if( p[ next[j] ] == p[j])
next[j] == next[next[j]]
如果新的 next[j] 依然 == p[j],那就继续跟新直到不相等为止.
这里 next[next[j]] 的含义是将 next 更新. 避免 pm[j-1] == pm[pm[j-1]] 的情况出现.
代码实现:
void get_nextval(int* next, const char* ptr, int ptr_len)
//在原有next
{
//将pm中的元素右移一位
next[0] = -1; //第0个元素为-1不作数
next[1] = 0; //第一个元素的公共前后缀必然为 0
for(int i = 2; i < ptr_len; ++i)
{
if(ptr[i - 1] == ptr[next[i - 1]])
//ptr[next[i-1]] 中 next[i-1] 为最长前缀末尾元素的坐标.
//ptr[i-1] 中为当前已经匹配元素的坐标.
//和pm的代码改动只有这里
{
next[i] = next[i - 1] + 1;
}
else
next[i] = 0;
while( ptr[next[i-1]] == ptr[i-1] && next[i-1]!=0)//更新操作
{
next[i-1] = next[next[i-1]];
}
}
for(int i = 0; i < ptr_len; ++i)
cout << next[i] << ' ';
cout << endl;
}
四. 完整代码
/***********************************************************
Author : Joe_Yang
Last modified: 2020-09-24 15:21
Email : 1514784049@qq.com || 1514784049yz@gmail.com
Weblog : https://blog.csdn.net/pursue_my_life/
Filename : tmp.cpp
Description : 本代码 模式串 ptr 从 0 开始, 所以不用+1
************************************************************/
#include <iostream>
#include <cstring>
using std::cout;
using std::cin;
using std::endl;
int volence(const char* str, int str_len, const char* ptr, int ptr_len)
{
int i = 0;
int j = 0;
while(i < str_len && j < ptr_len)
{
if(str[i] == ptr[j])//匹配相等则继续
{
++i;
++j;
}
else
{
j = 0;// p 串匹配失败了要从头开始匹配
i = i - j + 1; //s 串失败了说明从 i 开始的串匹配失败, 所以要向右移动一位到 i+1再进行匹配, 又因为和错误的串匹配已经前进了j个单位,所以要 - j 个单位.
}
}
if(j == ptr_len)//代表匹配上了
{
return i - j;//i 代表已经匹配上的串的末尾的下一个, 减去长度 j 即可得到串首的下标
}
return -1;
}
void get_pm(int* next, const char* ptr, int ptr_len)
{
//最长公共前后缀
next[0] = 0; //第一个元素必然为0
for(int i = 1; i < ptr_len; ++i)
{
if(ptr[i] == ptr[next[i - 1]])//ptr[next[i-1]] 中 next[i-1] 为最长前缀末尾元素的坐标.
{
next[i] = next[i - 1] + 1;
}
else
next[i] = 0;
}
for(int i = 0; i < ptr_len; ++i)
cout << next[i] << ' ';
cout << endl;
}
void get_next(int* next, const char* ptr, int ptr_len)
{
//将pm中的元素右移一位
next[0] = -1; //第0个元素为-1不作数
next[1] = 0; //第一个元素的公共前后缀必然为 0
for(int i = 2; i < ptr_len; ++i)
{
if(ptr[i - 1] == ptr[next[i - 1]])
//ptr[next[i-1]] 中 next[i-1] 为最长前缀末尾元素的坐标.
//ptr[i-1] 中为当前已经匹配元素的坐标.
//和pm的代码改动只有这里
{
next[i] = next[i - 1] + 1;
}
else
next[i] = 0;
}
for(int i = 0; i < ptr_len; ++i)
cout << next[i] << ' ';
cout << endl;
}
void get_nextval(int* next, const char* ptr, int ptr_len)
//在原有next
{
//将pm中的元素右移一位
next[0] = -1; //第0个元素为-1不作数
next[1] = 0; //第一个元素的公共前后缀必然为 0
for(int i = 2; i < ptr_len; ++i)
{
if(ptr[i - 1] == ptr[next[i - 1]])
//ptr[next[i-1]] 中 next[i-1] 为最长前缀末尾元素的坐标.
//ptr[i-1] 中为当前已经匹配元素的坐标.
//和pm的代码改动只有这里
{
next[i] = next[i - 1] + 1;
}
else
next[i] = 0;
while( ptr[next[i-1]] == ptr[i-1] && next[i-1]!=0)//更新操作
{
next[i-1] = next[next[i-1]];
}
}
for(int i = 0; i < ptr_len; ++i)
cout << next[i] << ' ';
cout << endl;
}
int kmp_by_using_pm(const char* str, int str_len, const char* ptr, int ptr_len, int* next)
{
get_pm(next, ptr, ptr_len);
int i = 0;
int j = 0;
while(i < str_len && j < ptr_len)
{
if(str[i] == ptr[j])
{
++i;
++j;
}
else if(j == 0)
//ps: 这里隐含了 str[i] != str[j] && j==0.
//即: str[0] != str[0]
//代表: 如果两个串的第一个元素就不相等, 则应该从主串的第i+1个位置开始,所以++i;
{
++i;
}
else//当匹配失效时,i不变,j 回退next[j-1]的位置继续比较
{
j = next[j - 1];
//cout << "j:" << j << endl;
}
}
if(j >= ptr_len)//此时i的位置减去匹配串的长度为首次找到的字符串的位置
return i - ptr_len;
return -1;
}
int kmp_by_using_next(const char* str, int str_len, const char* ptr, int ptr_len, int* next)
{
get_next(next, ptr, ptr_len);
int i = 0;
int j = 0;
while(i < str_len && j < ptr_len)
{
if(str[i] == ptr[j])
{
++i;
++j;
}
else if(j == 0)
//ps: 这里隐含了 str[i] != str[j] && j==0.
//即: str[0] != str[0]
//代表: 如果两个串的第一个元素就不相等, 则应该从主串的第i+1个位置开始,所以++i;
{
++i;
}
else//当匹配失效时,i不变,j 回退next[j]的位置继续比较
{
j = next[j];
//cout << "j:" << j << endl;
}
}
if(j >= ptr_len)//此时i的位置减去匹配串的长度为首次找到的字符串的位置
return i - ptr_len;
return -1;
}
int kmp_by_using_nextval(const char* str, int str_len, const char* ptr, int ptr_len, int* next)
{
get_nextval(next, ptr, ptr_len);
int i = 0;
int j = 0;
while(i < str_len && j < ptr_len)
{
if(str[i] == ptr[j])
{
++i;
++j;
}
else if(j == 0)
//ps: 这里隐含了 str[i] != str[j] && j==0.
//即: str[0] != str[0]
//代表: 如果两个串的第一个元素就不相等, 则应该从主串的第i+1个位置开始,所以++i;
{
++i;
}
else //当匹配失效时,i不变,j 回退next[j-1]的位置继续比较
{
j = next[j];
//cout << "j:" << j << endl;
}
}
if(j >= ptr_len)//此时i的位置减去匹配串的长度为首次找到的字符串的位置
return i - ptr_len;
return -1;
}
int main()
{
const char *str = "bacbababadababacambabacaddababacasdsd";
const char *ptr = "ababaca";
int next[100];//告诉我们:当模式串中某个字符跟文本串中某个字符失配时,模式串下一步应该跳到next[j]这个位置.
int str_len = strlen(str);
int ptr_len = strlen(ptr);
//cout << volence(str, str_len, ptr, ptr_len) << endl;;
//get_pm(next, ptr, ptr_len);
get_nextval(next, ptr, ptr_len);
//cout << kmp_by_using_pm(str, str_len, ptr, ptr_len, next) << endl;
//cout << kmp_by_using_pm(str, str_len, ptr, ptr_len, next) << endl;
//cout << kmp_by_using_next(str, str_len, ptr, ptr_len, next) << endl;
cout << kmp_by_using_nextval(str, str_len, ptr, ptr_len, next) << endl;
return 0;
}
2308
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
