常用算法3 - 字符串查找/模式匹配算法(BF & KMP算法)

Posted Jimmy_Nie

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了常用算法3 - 字符串查找/模式匹配算法(BF & KMP算法)相关的知识,希望对你有一定的参考价值。

相信我们都有在linux下查找文本内容的经历,比如当我们使用vim查找文本文件中的某个字或者某段话时,Linux很快做出反应并给出相应结果,特别方便快捷!
那么,我们有木有想过linux是如何在浩如烟海的文本中正确匹配到我们所需要的字符串呢?这就牵扯到了模式匹配算法!

1. 模式匹配

什么是模式匹配呢?

  • 模式匹配,即子串P(模式串)在主串T(目标串)中的定位运算,也称串匹配

假设我们有两个字符串:T(Target, 目标串)和P(Pattern, 模式串);在目标串T中查找模式串T的定位过程,称为模式匹配.

模式匹配有两种结果:

  • 目标串中找到模式为T的子串,返回P在T中的起始位置下标值;
  • 未成功匹配,返回-1

通常模式匹配的算法有很多,比如BF、KMP、BM、RK、SUNDAY等等,它们各有千秋,我们此处重点讲解BF和KMP算法(因为比较常用)

2. BF算法

BF,即Brute-Force算法,也称为朴素匹配算法蛮力算法,效率较低!

1). 算法思想

基本思想:

    1. 将目标串T第一个字符与模式串P的第一个字符比较;
    1. 若相等,则比较T和P的第二个字符
    1. 若不等,则比较T的下一个字符与P的第一个字符
    1. 重复步骤以上步骤,直到匹配成功或者目标串T结束

流程图如下:
技术分享图片

例如:
T=‘ababcabcacbab‘, P=‘abcac‘, 匹配流程
技术分享图片

  • Step 1: 主串T与子串P做顺序比较,当比较到位置2时,主串T[2]=‘a‘与子串P[2]=‘c‘不等(蓝色阴影表示),记录各自的结束位置,并进入Step 2
  • Step 2: 主串T后移一位,主串T与子串P再从头开始比较,比较如Step 1
  • Step 3: 每次比较,子串都从0开始,主串的开始位置与上次的结束位置存在一定的关系;在某些时候需要“回溯”(上次比较结束的位置要向前移动);如Step 1的结束位置为2,Step 2的开始位置为1;Stp3的结束位置为6,Step 4的开始位置为3等;
  • Step 4: 主串T的索引值i 与 子串P的索引值j的关系为:i=i-j+1

2). 代码实现

/*-----------------------------------------------------------------------------
 * Function: BF - Does the P can be match in T
 * Input:   Pattern string P, Target string T
 * Output:  If matched: the index of first matched character
 *          else: -1
-----------------------------------------------------------------------------*/
int BF(const string &T, const string &P)
{
    int j=0, i=0, ret=0;

    while((j < P.length()) && (i<T.length()))
    {
        if(P[j] == T[i])    //字符串相等则继续
        {
            i++;
            j++;        //目标串和子串进行下一个字符的匹配
        }
        else
        {
            i = i - j + 1;
            j = 0;              //如果匹配不成功,则从目标字符串的下一个位置开始从新匹配
        }
    }

    if(i < T.length())      //若匹配成功,返回匹配的第一个字符的下标值
        ret = i - P.length() ;
    else
        ret = -1;

    return ret;
}

3). 效率分析

效率分析主要是分析时间复杂度和空间复杂度. 而本例的空间复杂度较低,暂时不做考虑,我们来看看时间复杂度。
分析时间复杂度通常是分析最坏情况,对于BF算法来说,最坏情况举例如下:
T="ggggggggk", P="ggk"

技术分享图片
由上图可知,第i次匹配,前面第i-1次匹配,每次都需要比较m次(m为模式串P的长度),因此为(i-1)m次;第i次匹配成功也需要m次比较,因此总共需要比较mi次。

对于长度为n的主串T,i=n-m+1,每次匹配成功的概率为Pi,且概率相等;则在最坏情况下,匹配成功的概率Cmax可表示为:

技术分享图片

一般情况下 n>>m,因此,BF的时间复杂度为 O(m*n)

3. KMP算法

BF算法每次都需要回溯,导致时间复杂度较大,那么有没有一种效率更高的模式匹配算法呢?
答案是肯定的,那就是KMP算法。

1). 名词解释

在进行算法讲解之前,必须要明确以下几个名词,否则无法理解此算法

  • 目标串 T: 即大量的等待被匹配的字符串
  • 模式串 P:即我们需要查找的字符串
  • 字符串前缀:字符串的任意首部(不包括最后一个字符);如"abcd"的前缀为"a","ab","abc",但不包括"abcd"
  • 字符串后缀:字符串的任意尾部(不包括第一个字符);如"abcd"的后缀为"d","cd","bcd",但不包括"abcd"
  • 字符串前后缀相等位数k:即前缀与后缀的最长匹配位数,技术分享图片

2). 算法思想

KMP算法的核心思想是:部分匹配,即不再把主串的位置移动到已经比较过的位置(不再回溯),而是根据上一次比较结果继续后移。
概念相当抽象,那么我们以例子来解释:
技术分享图片

  • Step 1: 匹配到索引值index=2时,匹配失败
  • Step 2: 匹配的开始位置为index=2(没有回溯到1), 原因如下:

    Step 1 比较后,已知T[1]=‘b‘, S[0]=‘a‘,理论上已经比较过了,所以无需回溯再次比较

Step 2 一直进行匹配,直到T[6]时刻失配.

  • Step 3: T的位置不进行回溯,还是保持在T[6]开始(KMP算法规定:目标串T不回溯,上一次的结束位置即为下一次的开始位置);
    P的索引值从1开始而非0,原因如下:

    在Step 2 中,T[5]=‘a‘已经比较过,我们已知,且与P[3]相等;因为P[0]==P[3],所以无需比较P[0]与T[5],因为Step 2 理论上已经进行了比较(其实就是看子串P Step2结束位置P[4]之前的P[0-3]的字符串前后缀相等位数k,使得P[k]与上次主串的结束位置T[6]对齐)

由以上分析可知,KMP算法过程中关键点就是求: 子串P结束位置前的前后缀相等位数k
下图是模式串P="abcabca"的前后缀关系分析(包括前后缀字符串相等位数k)
技术分享图片

由上图我们可以给出,T串每一个字符做结束位置时,下一次的开始位置的值;

  • j 为T的本次匹配结束位置(失配位置);
  • next[j] 为下次匹配模式串P的开始位置

技术分享图片
PS: next[j]就是前后缀字符串相等位数k

根据上面的讨论,我们可以得出next[j]的运算公式:
技术分享图片
其中,-1 是一个标记,标识下一次的开始位置目标串为技术分享图片,模式串P为技术分享图片

如果以上你没有明白,不要紧的,只需要记住next[j]的函数就可以,其它一切都是根据它来的!

3). 代码实现

/*-----------------------------------------------------------------------------
 * Function: KMP- Does the P can be match in T
 * Input:   Pattern string P, array next
 * Output:  If matched: the index of first matched character
 *          else: -1
-----------------------------------------------------------------------------*/
void getNext(const string &P, int next[])
{
    int j=0;    //模式串P的下标值/索引值
    int k=-1;   //模式串P的前缀和后缀串相等的位数
    next[0]=-1; //置初值

    while(j < P.length())
    {
        if((k == -1) || (P[j] == P[k])) //从模式串P的开始位置处理 或 顺序比较主串和子串
        {
            j++;
            k++;
            next[j] = k;
        }

        else            //设置重新比较位置:j串不变,k串从next[k]位置开始
            k = next[k];
    }
}

/*-----------------------------------------------------------------------------
 * Function: KMP- Does the P can be match in T
 * Input:   Pattern string P, Target string T
 * Output:  If matched: the index of first matched character
 *          else: -1
-----------------------------------------------------------------------------*/
int KMP(const string &T, const string &P)
{
    int next[MaxSize]={0};
    int i=0;    //目标串T的下标值/索引值
    int j=0;    //模式串P的下标值/索引值
    int ret=0;

    getNext(P, next);   //获取模式串P的next数组

    int PLen = P.length();
    int TLen = T.length();

    while((i < T.length()) && (j < PLen))   //奇怪,此处我用 j<P.length()就不行,待解决
    {
        if((j==-1) || (P[j] == T[i]))   //j=-1表示首次比较
        {
            i++;
            j++;
        }

        else
        {
            j = next[j];
        }
    }

    if(j >= P.length())
        ret = i-P.length();
    else
        ret = -1;

    return ret;
}

4). 效率分析

由于KMP算法不回溯,比较是顺序进行的,因此最坏情况下的KMP时间复杂度为 O(m+n).
其中,m为模式串P的字符串长度,n为目标串T的字符串长度.

































以上是关于常用算法3 - 字符串查找/模式匹配算法(BF & KMP算法)的主要内容,如果未能解决你的问题,请参考以下文章

字符串匹配基础上

数据结构与算法之美-字符串匹配(上)

【算法笔记】字符串匹配

Python数据结构:BF算法匹配括号回文链表生成螺旋矩阵移除列表元素计算后缀表达式的值顺时针旋转n维矩阵90度折半查找

Python 细聊从暴力(BF)字符串匹配算法到 KMP 算法之间的精妙变化

BF字符串匹配算法