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

Posted 2020-10-23 Jimmy_Nie

相信我们都有在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的字符串长度.