图解+原理推导完全读懂KPM算法

最新推荐文章于 2024-10-06 21:02:27 发布

置顶 ^鸢飞鱼跃^

最新推荐文章于 2024-10-06 21:02:27 发布

阅读量1.1k

点赞数 1

分类专栏：数据结构 c语言文章标签：算法数据结构字符串

本文链接：https://blog.csdn.net/weixin_44563671/article/details/112210856

版权

数据结构同时被 2 个专栏收录

7 篇文章 0 订阅

订阅专栏

c语言

7 篇文章 0 订阅

订阅专栏

文章目录

串定长顺序存储方式
串的模式匹配

串定长顺序存储方式

我们显式地在串的索引为0处存储串长。

#define MAXSTRLEN 255   // 用户可在255以内定义最大串长
typedef unsigned char SString[MAXSTRLEN＋1]; //0号单元存放串的长度

串的模式匹配

模式匹配：设有主串S和子串T，子串在主串中的定位称为模式匹配或串匹配(字符串匹配) 。
通常也把主串S称为目标串，把子串T称为模式串。
模式匹配成功是指在目标串S中找到一个模式串T是S的子串，返回T在S中的位置。
模式匹配不成功则指目标串S中不存在模式串T不是S的子串，返回-1。

BF算法

又称简单的、朴素的、穷举的模式匹配算法。算法的思路是
将主串的第 i 个字符和模式的第一个字符比较，

若相等，继续逐个比较后续字符；直到主串的一个连续子串字符序列与模式相等。返回值为主串中模式串匹配的子序列第一个字符的序号，即匹配成功。
若不等，从主串的下一字符起，重新与模式的第一个字符比较。

int Index_BF( SString S, SString T )
{// 返回模式串T在主串S中的位置。若不存在，则返回0。T非空
    int i = 1，j = 1;
    while ( i <= S[0] && j <= T[0] ) 
    {
        if ( S[i] == T[j] ) {++i;++j;} // 继续比较后续字符
        else {i = i - j + 2;j = 1;} // 指针回溯重新开始下一趟匹配
    }
    if(j>T[0]) return i-T[0]; //返回匹配成功时主串对应的第一个字符的下标
    else return 0; //模式匹配不成功
} // Index_BF

时间复杂度：若主串s长度为n，模式串t长度为m
最好情况下的时间复杂度为O(m)。
算法在字符比较不相等，需要回溯（即i=i-j+1）：即退到s中的下一个字符开始进行继续匹配。
最坏情况下每趟比较m次，进行 $n － m ＋ 1$ 趟匹配，总比较次数为 $m (n - m + 1)$ ，时间复杂度为 $O (n \times m)$ 。

KMP算法

KMP算法原理

KMP算法一种改进的模式匹配算法，是D.E.Knuth、V.R.Pratt、J.H.Morris于1977年联合发表，KMP算法又称克努特-莫里斯-普拉特操作。KMP算法的设计思想：当出现不匹配时，利用已经比较过的已知内容，来避免将主串指针回退到已比较的字符之前。

实现KMP算法需要解决的问题：

为什么主串的“指针”：i可以不回溯？
若某趟在 $S_i$ 和 $T_j$ “失配”时，
$_{1} \sim T _{ j -1}= S _{ i - j +1} \sim S _{ i -1}$
主串的切片 $_{ i - j +1} \sim S _{ i -1}$ 的后缀中是否有能成功匹配的前缀，仅和 $_{1} \sim T _{ j -1}$ 的性质有关，可以在匹配算法之前预计算出来。
若某趟在 $S_i$ 和 $T_j$ “失配”时，主串中i不回溯，下一步进行 $S_i$ 与 $T_k$ 的比较，那么k如何求出？
$_{ i - k +1} \sim S _{ i -1}$ 的后缀必须是T的前缀：
$_{1} \sim T _{ k -1}= S _{ i - k +1} \sim S _{ i -1}$
$_{ i - k +1} \sim S _{ i -1}$ 在上一步已经与T匹配的部分：
$_{ j - k +1} \sim T _{ j -1}= S _{ i - k +1} \sim S _{ i -1}$
联立得：
$_{1} \sim T _{ k -1}= T _{ j - k +1} \sim T _{ j -1}$
k的解集为 $K=\{ k \mid k=2,3,...,j-1 \text { 且 }T _{1} \sim T _{ k -1}= T _{ j - k +1} \sim T _{ j -1} \}$
k越大，模式串滑动的距离越小，为了避免遗漏选取k的最大值 $k=\max K$

模式中的前k-1个字符（最大真前缀）与模式中 $T_j$ 字符前面的k-1个字符（最大真后缀）相等时，模式T就可以向右"滑动"至使 $T_k$ 和 $S_i$ 对准，继续向右进行比较即可。

在这里插入图片描述

滑动位置k仅与模式串T有关。
因此可以预先为模式串设定一个next数组，若令next[j]=k，则next[j]表明当模式串中的第j个字符与主串中相应字符“失配”时，模式串中需要重新和主串中该字符进行比较的字符的位置。
$next[j]=\left\{\begin{array}{ll}0, & 当 j=1 时 \\ k=\max K, & 当 j\geq2, k\neq \varnothing \\ 1, & 当 j\geq2, k= \varnothing \end{array}\right.$
其中 $K=\{ k \mid k=2,3,...,j-1 \text { 且 }T _{1} \sim T _{ k -1}= T _{ j - k +1} \sim T _{ j -1} \}$
next[1]=0 表示T[1]与S[i]失配，下一步进行T[1]与S[i+1]的比较。
next[j]=1 表示 $_{ i - k +1} \sim S _{ i -1}$ 的后缀都不为T的前缀：下一步进行T[1]与S[i]的比较。

KMP算法实现

int Index_KMP(SString S, SString T, int pos, int next[])
{// 利用模式串T的next函数求T在主串S中第pos个字符之后的位置的KMP算法
// 其中，T非空，1≤pos≤StrLength(S)。
    int i = pos, j = 1;
    while ( i<=S[0] && j<=T[0] )
    {  
          if ( j==0 || S[i]==T[j] ){++i; ++j; } // 继续比较后继字符
          else j=next[j]; // 模式串向右移动
    }
    if(j > T[0]) return i-T[0]; // 匹配成功，返回匹配模式串的首字符下标
    else return 0; //匹配失败
} // Index_KMP

求模式串T的next值算法

显然，next[1]=0， next[2]=1
如果next[j] =k，表明有 $_{1} \sim T _{ k -1}= T _{ j - k +1} \sim T _{ j -1}$ ，此时next[j+1]可能有两种情况：
(1). $T_k=T_j$ ，则 $_{1} \sim T _{ k }= T _{ j - k +1} \sim T _{ j }$ ，因此next[j+1]=next[j]+1=k＋1；
(2). $T_k\neq T_j$ ，则相当于在模式串 $_{1} \sim T _{ k }$ 与主串 $T$ 的模式匹配问题中k于j失配，设 $k^{'} = n e x t [k]$ ，
若 $k'\geq 2$ ，则有 $_{1} \sim T _{ k' -1}= T _{ j - k' +1} \sim T _{ j -1}$ ，将k’赋给k并返回步骤2. ；
否则说明 $_{ j - k +1} \sim T _{ j -1}$ 的真后缀中没有 $_{1} \sim T _{ k }$ 的前缀，则next[j+1]=1

void get_next( SString T, int &next[] )
{// 求模式串T的next函数值并存入数组next
    int i = 1, k = 0; next[1] = 0; 
    while ( i < T[0] ) 
    {	if ( k == 0 || T[i] == T[k] )    
        {  
            ++i;++k;     
            next[i] = k;     
        }
        else k = next[k];
    }
} // get_next

时间复杂度分析

BF算法分析

最好情况下的时间复杂度为 $O (m)$ 。
算法在字符比较不相等，需要回溯（即i=i-j+1）：即退到s中的下一个字符开始进行继续匹配。
最坏情况下每趟比较m次，进行n－m＋1趟匹配，总比较次数为m(n-m+1)，时间复杂度为 $O (n \times m)$ 。平均时间复杂度 $O (n \times m)$