常用算法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结束

流程图如下:
《常用算法3 - 字符串查找/模式匹配算法(BF & KMP算法)》

例如:
T=‘ababcabcacbab', P='abcac', 匹配流程
《常用算法3 - 字符串查找/模式匹配算法(BF & KMP算法)》

  • 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”

《常用算法3 - 字符串查找/模式匹配算法(BF & KMP算法)》
由上图可知,第i次匹配,前面第i-1次匹配,每次都需要比较m次(m为模式串P的长度),因此为(i-1)m次;第i次匹配成功也需要m次比较,因此总共需要比较mi次。

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

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

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

3. KMP算法

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

1). 名词解释

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

  • 目标串 T: 即大量的等待被匹配的字符串
  • 模式串 P:即我们需要查找的字符串
  • 字符串前缀:字符串的任意首部(不包括最后一个字符);如”abcd”的前缀为”a”,”ab”,”abc”,但不包括”abcd”
  • 字符串后缀:字符串的任意尾部(不包括第一个字符);如”abcd”的后缀为”d”,”cd”,”bcd”,但不包括”abcd”
  • 字符串前后缀相等位数k:即前缀与后缀的最长匹配位数,《常用算法3 - 字符串查找/模式匹配算法(BF & KMP算法)》

2). 算法思想

KMP算法的核心思想是:部分匹配,即不再把主串的位置移动到已经比较过的位置(不再回溯),而是根据上一次比较结果继续后移。
概念相当抽象,那么我们以例子来解释:
《常用算法3 - 字符串查找/模式匹配算法(BF & 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)
《常用算法3 - 字符串查找/模式匹配算法(BF & KMP算法)》

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

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

《常用算法3 - 字符串查找/模式匹配算法(BF & KMP算法)》
PS: next[j]就是前后缀字符串相等位数k

根据上面的讨论,我们可以得出next[j]的运算公式:
《常用算法3 - 字符串查找/模式匹配算法(BF & KMP算法)》
其中,-1 是一个标记,标识下一次的开始位置目标串为《常用算法3 - 字符串查找/模式匹配算法(BF & KMP算法)》,模式串P为《常用算法3 - 字符串查找/模式匹配算法(BF & KMP算法)》

如果以上你没有明白,不要紧的,只需要记住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的字符串长度.

    原文作者:Jimmy_Nie
    原文地址: https://www.cnblogs.com/Jimmy1988/p/8407166.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞