---

前言: 如何匹配字符串???

如对于以下两个字符串：

char *str = "bacbababadababacambabacaddababacasdsd";
char *ptr = "ababaca";

如何判断 str 串中是否有 ptr 串?? 如果有, 请给出匹配到的字符串的下标.

通常而言，进行字符串匹配有两种做法：

• 暴力法
• KMP 法

一. 暴力匹配字符串

1.1 暴力算法描述

暴力法步骤如下:

1. 从目标字符串str 的 i (第一次为首元素) 起 截取ptr长度(长度为m) 的子字符串进行比较
2. 如果一样，就返回匹配到的子串的下标值.
3. 不一样，i = i+1 .(且 ptr 指针回退到 0 (即令 j == 0)).
4. 重复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;elsepm[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; //第一个元素的公共前后缀必然为 0for(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;}elsenext[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 的步骤为：

1. 从目标字符串str（假设长度为n）的首元素起 截取ptr长度(长度为m) 的子字符串进行比较
2. 如果一样，就返回匹配到的子串的下标值.
3. 不一样，就将
   ptr 第一个匹配失败所在元素的的下标 j , 回退到这个最长公共前后缀后的一位
   再同样选取长度为n的字符串进行比较.
   (或者可以理解为: ptr整体 滑动到 ptr 的另一个靠后最长公共前后缀处,)
4. 直到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; //第一个元素的公共前后缀必然为 0for(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;}elsenext[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_YangLast modified: 2020-09-24 15:21Email        : 1514784049@qq.com || 1514784049yz@gmail.comWeblog       : https://blog.csdn.net/pursue_my_life/Filename     : tmp.cppDescription  : 本代码 模式串 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; //第一个元素必然为0for(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;}elsenext[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; //第一个元素的公共前后缀必然为 0for(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;}elsenext[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; //第一个元素的公共前后缀必然为 0for(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;}elsenext[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;
}

KMP 看毛片算法原理及其实现相关推荐

1. 王道数据结构课代表 - 考研数据结构 第四章 串-KMP(看毛片算法) 究极精华总结笔记（C版本）

   本篇博客是考研期间学习王道课程 传送门 的笔记,以及一整年里对数据结构知识点的理解的总结.希望对新一届的计算机考研人提供帮助!!!   关于对 串 章节知识点总结的十分全面,涵括了<王道数据结构 ...

2. KMP算法——俗称看毛片算法

   咳咳咳,这是看毛片算法的简单介绍 首推一个博客,这个博客很优秀,我的KMP算法就是从上面学来的--https://www.cnblogs.com/yjiyjige/p/3263858.html 算法思 ...

3. 每日算法练习——模式匹配KMP算法（看毛片算法？）

   知识补充: 在计算机科学中,Knuth-Morris-Pratt字符串查找算法(简称为KMP算法)可在一个主文本字符串S内查找一个词W的出现位置.此算法通过运用对这个词在不匹配时本身就包含足够的信息来 ...

4. [看毛片算法][KM]zoj 3615：Choir II

   大致题意:     有n个男生,m个女生,每个人用一句话描述其他的异性.对与第i个人和第j个异性,其好感值为其姓名第一次出现的位置和出现次数的乘积.现在要匹配这些人,使得总的好感值之和最大,求这个值. ...

5. 谱聚类算法原理（一）

   谱聚类(spectral clustering)是广泛使用的聚类算法,比起传统的K-Means算法,谱聚类对数据分布的适应性更强,聚类效果也很优秀,同时聚类的计算量也小很多,更加难能可贵的是实现起来也 ...

6. KMP算法原理描述，告诉你为什么要“j = next[j]”

   KMP算法原理描述,告诉你为什么要"j = next[j]" 研究KMP算法的起因,是在刷leetcode的 214.最短回文串时,一开始使用了 O ( n 2 ) O(n^2) ...

7. xgboost算法原理_从XGB到SecureBoost:看联邦学习XGB的算法原理

   摘要: 最近与某厂完成基于FATE的联邦学习框架的一个项目,第一次实践了一把联邦学习在实际业务场景中的应用,从模型评估结果来看,效果还不错.因此,本文将完成对于其中实现的提升算法SecureBoost ...

8. 算法 - KMP算法原理顿悟有感

   算法 - KMP算法原理顿悟有感 KMP? KMP核心思想 举个栗子 上点代码 next数组 (1)若P~j~ == P~t~ (2) 若P~j~ 和 P~t~不相等 改进上面的KMP算法 nextv ...

9. java移动平均线算法_移动平均线怎么看，它的原理与算法是什么？

   原标题:移动平均线怎么看,它的原理与算法是什么? 移动平均线的定义是将一段时期的股票价格加以平均,然后把不同时间的平均值连接起来成一条线,这就是移动平均线的本质,具体如何将股价加以平均就是它的算法问题 ...

最新文章

1. Silverlight 参考：三维效果（透视转换） -- MSN
2. Java的TheadLocal使用
3. Twitter Storm安装配置（Ubuntu系统）单机版
4. Java、Android、oc冒泡排序算法随笔
5. c语言和电脑猜拳,c语言编写和电脑猜拳的游戏
6. Flutter 即学即用系列博客——09 MethodChannel 实现原生与 Flutter 通信（二）
7. Java8 的 Stream API 的确牛X，但性能究竟如何呢？
8. opencv_找cv::Mat中的最大值和最小值
9. svn clean up 失败
10. 创业管理：创业者的十八般武艺——1.2 创业者素质体系（1）
11. 吴军的数学通识讲义 读书笔记
12. 后台管理页面通过点击左侧导航栏的菜单项实现右边内容的改变
13. 浅谈加密技术在电子商务中的应用
14. 至联云课堂：隐私泄露屡禁不止，根本原因其实是...
15. 我为什么加入 TDengine
16. 世界上第一台电子计算机的配置,1 世界上第一台电子计算机诞生于年
17. 如何使用 Redis 实现 “附近的人” 这个功能？
18. iOS开发键盘设置,IOS7深灰色键盘
19. Java后端基础知识笔记
20. js删除css某个属性值

热门文章

1. RuntimeError: Sizes of tensors must match except in dimension 2. Got 5 and 4
2. Opencv 笔记8 霍夫变换
3. 获取企业微信授权code
4. google map 看经度和纬度
5. python计算线性相关系数_Python+pandas计算数据相关系数(person、Kendall、spearman)
6. 基于Ubuntu(x86)系统和STM32(Keil)编写C程序分别进行编程、验证
7. matlab 可见度和衬噪比
8. 基于golang的爬虫demo，爬取微博用户的粉丝和关注者信息
9. windows编程学习——1 关闭窗口不退出
10. 量子理论学习：概率幅