字符串匹配(BF,BM,Sunday,KMP算法解析)

字符串匹配一直是计算机领域热门的研究问题之一，多种算法层出不穷。字符串匹配算法有着很强的实用价值，应用于信息搜索，拼写检查，生物信息学等多个领域。
今天介绍几种比较有名的算法：
1. BF
2. BM
3. Sunday
4. KMP

—，BF算法
BF(Brute Force)算法又称为暴力匹配算法，是普通模式匹配算法。

其算法思想很简单，从主串S的第pos个字符开始，和模式串T的第一个字符进行比较，若相等，则主串和模式串都后移一个字符继续比较；若不相同，则回溯到主串S的第pos+1个字符重新开始比较。
依次类推，直到模式串T中每个字符依次和主串S中的一个连续字符串全部相等时，则匹配成功，返回模式串T的第一个字符在主串S中的位置；若主串遍历完也没有成功，则匹配失败。

算法步骤如下：

下标i    0  1  2  3  4  5  6  7  8  9  
主串S    a  b  a  b  c  a  b  c  a  c  
模式串T  a  b  c  a          

第一次比较，从左到右，S[0] = T[0]，计数器++；比较S[1] = T[1]，i++；当s[2] != T[2]，主串回溯，从S[1]重新开始比较。

下标i    0  1  2  3  4  5  6  7  8  9  
主串S    a  b  a  b  b  a  b  c  a  c  
模式串T     a  b  c  a          

也就是说，主串i从0开始，每次比较失败i++，重新比较，直到

下标i    0  1  2  3  4  5  6  7  8  9  
主串S    a  b  a  b  b  a  b  c  a  c  
模式串T                 a  b  c  a   

i = 5,匹配成功。返回 i=5。

可推得，BF算法在最坏情况下需要比较，主串长度M 乘以 模式串长度N, 为-O（M * N）。

代码实现如下：

int BF(const char *str1, const char *str2)
{
    int str1_len = strlen(str1);
    int str2_len = strlen(str2);
    int i = 0;
    int j = 0;

    if(str1 == NULL || str2 == NULL){
        return -1;
    }

    while(i < str1_len && j < str2_len){
        if(str1[i] == str2[j]){
            i++;
            j++;
            //相等则继续逐个比较
        }
        else{
            i = i -j + 1;
            j = 0;
            //不相等则主串回溯，重新比较
        } 
    }
    if (j == str2_len){

        return i - j;
    }else{
    return -1;
    }
}

BF算法简单易懂，但是这个算法效率很差，原因在于每次失败后回溯，浪费了之前的比较，导致了很多次的无用比较，时间损耗较大。

二，BM算法
BM(Boyer Moore)算法是1977年，Robert S.Boyer和J Strother Moore提出了一种在O(n)时间复杂度的匹配算法。时间复杂度要低于BF。

BM算法之所以能够在模式匹配中有更高的的效率，主要是因为BM算法构造了两个跳转表，分别叫做 坏后缀表 ，和 好后缀表 。这两个表涉及了BM算法中的两个规则：

坏字符规则：当文本串中的某个字符跟模式串的某个字符不匹配时，我们称文本串中的这个失配字符为坏字符，此时模式串需要向右移动，移动的位数 = 坏字符在模式串中的位置 - 坏字符在模式串中最右出现的位置。此外，如果”坏字符”不包含在模式串之中，则最右出现位置为-1。

好后缀规则：当字符失配时，后移位数 = 好后缀在模式串中的位置 - 好后缀在模式串上一次出现的位置，且如果好后缀在模式串中没有再次出现，则为-1。

算法步骤如下：
1. 首先，”文本串”与”模式串”头部对齐，从尾部开始比较。”S”与”E”不匹配。这时，”S”就被称为”坏字符”（bad character），即不匹配的字符，它对应着模式串的第6位。且”S”不包含在模式串”EXAMPLE”之中（相当于最右出现位置是-1），这意味着可以把模式串后移6-(-1)=7位，从而直接移到”S”的后一位。

2. 依然从尾部开始比较，发现”P”与”E”不匹配，所以”P”是”坏字符”。但是，”P”包含在模式串”EXAMPLE”之中。因为“P”这个“坏字符”对应着模式串的第6位（从0开始编号），且在模式串中的最右出现位置为4，所以，将模式串后移6-4=2位，两个”P”对齐。

3. 依次比较，得到 “MPLE”匹配，称为”好后缀”（good suffix），即所有尾部匹配的字符串。注意，”MPLE”、”PLE”、”LE”、”E”都是好后缀。

4. 发现“I”与“A”不匹配：“I”是坏字符。如果是根据坏字符规则，此时模式串应该后移2-(-1)=3位。问题是，有没有更优的移法？

5. 更优的移法是利用好后缀规则：当字符失配时，后移位数 = 好后缀在模式串中的位置 - 好后缀在模式串中上一次出现的位置，且如果好后缀在模式串中没有再次出现，则为-1。
所有的“好后缀”（MPLE、PLE、LE、E）之中，只有“E”在“EXAMPLE”的头部出现，所以后移6-0=6位。
可以看出，“坏字符规则”只能移3位，“好后缀规则”可以移6位。每次后移这两个规则之中的较大值。这两个规则的移动位数，只与模式串有关，与原文本串无关。

6. 继续从尾部开始比较，“P”与“E”不匹配，因此“P”是“坏字符”，根据“坏字符规则”，后移 6 - 4 = 2位。因为是最后一位就失配，尚未获得好后缀。

匹配完成，可见BM算法根据好坏字符规则，使得失配时，文本串能够后移更多位，使得效率高于BF按部就班的匹配。

BM算法的时间复杂度为-O（N）。

代码实现主要在于构建两表。
坏字符表：

void BuildBadC(const char* pattern, size_t pattern_length, unsigned int* badc, size_t alphabet_size)  
{  
    unsigned int i;  

    for(i = 0; i < alphabet_size; ++i)  
    {  
        badc[i] = pattern_length;  
    }   
    for(i = 0; i < pattern_length; ++i)  
    {  
        badc[pattern[i] - ‘A‘] = pattern_length - 1 - i;  
    }  
}  

好后缀表：

void BuildGoodS(const char* pattern, size_t pattern_length, unsigned int* goods)  
{  
    unsigned int i, j, c;  

    for(i = 0; i < pattern_length - 1; ++i)  
    {  
        goods[i] = pattern_length;  
    }  
    //初始化pattern最末元素的好后缀值  
    goods[pattern_length - 1] = 1;    
    //此循环找出pattern中各元素的pre值，这里goods数组先当作pre数组使用  
    for(i = pattern_length -1, c = 0; i != 0; --i)  
    {  
        for(j = 0; j < i; ++j)  
        {  
            if(memcmp(pattern + i, pattern + j, (pattern_length - i) * sizeof(char)) == 0)  
            {  
                if(j == 0)  
                {  
                    c = pattern_length - i;  
                }  
                else  
                {  
                    if(pattern[i - 1] != pattern[j - 1])  
                    {  
                        goods[i - 1] = j - 1;  
                    }  
                }  
            }  
        }  
    }    
    //根据pattern中个元素的pre值，计算goods值  
    for(i = 0; i < pattern_length - 1; ++i)  
    {  
        if(goods[i] != pattern_length)  
        {  
            goods[i] = pattern_length - 1 - goods[i];  
        }  
        else  
        {  
            goods[i] = pattern_length - 1 - i + goods[i];  

            if(c != 0 && pattern_length - 1 - i >= c)  
            {  
                goods[i] -= c;  
            }  
        }  
    }  
}  

构建完表BM算法就很简单了。

unsigned int BM(const char* text, size_t text_length, const char* pattern, size_t pattern_length, unsigned int* matches)  
{  
    unsigned int i, j, m;  
    unsigned int badc[ALPHABET_SIZE];  
    unsigned int goods[pattern_length];   
    i = j = pattern_length - 1;  
    m = 0;  

    //构建好后缀和坏字符表  
    BuildBadC(pattern, pattern_length, badc, ALPHABET_SIZE);  
    BuildGoodS(pattern, pattern_length, goods);  

    while(j < text_length)  
    {  
        //发现目标传与模式传从后向前第1个不匹配的位置  
        while((i != 0) && (pattern[i] == text[j]))  
        {  
            --i;  
            --j;  
        }  
        //找到一个匹配的情况  
        if(i == 0 && pattern[i] == text[j])  
        {  
            matches[m++] = j;  
            j += goods[0];  
        }  
        else  
        {  
            //坏字符表用字典构建比较合适  
            j += goods[i] > badc[text[j]-‘A‘] ? goods[i] : badc[text[j]-‘A‘];  
        }  
        i = pattern_length - 1;  
    }  

    return m;  
}  

BM算法的思想在字符串匹配中很重要，其中好后缀与KMP算法的思想不谋而合，而坏字符跳跃，跟Sunday算法很相似。总的来说，BM是很高效的匹配算法。

三,Sunday算法
Sunday算法是Daniel M.Sunday于1990年提出的字符串模式匹配。据网上说，Sunda算法的效率高于BM和KMP(不太明白)。在我看来，Sunday算法是BM算法的优化，逻辑简单易懂，代码也实现更容易(无需构造两表)。

Sunday算法的思想是：
1. 从文本串S的第pos个字符开始，和模式串T的第一个字符进行比较，若相等，则主串和模式串都后移一个字符继续比较；
2. 若不相同，则将文本串参与匹配的最末位字符的后一个字符与模式串逆着匹配。
3. 若匹配完模式串没有该字符，则模式串直接跳过，即移动位数 = 匹配串长度 + 1。
4. 若模式串匹配到了该字符，则模式串中相同字符移动到文本串该字符下，与该字符对齐。其移动位数 = 模式串中最右端的该字符到末尾的距离+1。

算法步骤如下：

下标i    0  1  2  3  4  5  6  7  8  9  10  11  12
主串S    c  b  a  b  d  c  b  a  c  b   b   a   d
模式串T  c  b  b  a    

从前往后比较，在i = 2处失配，关注i= 4( d )是否包含在模式串T中。遍历比较完发现不包含，将模式T移动到i = 5继续比较。(失配后，主串这轮参与比较的后一位（d）肯定要参与下一轮的比较，T中都没有d，肯定匹配不成功啊！还比什么，直接后移至（d）的下一位。)

下标i    0  1  2  3  4  5  6  7  8  9  10  11  12
主串S    c  b  a  b  d  c  b  a  c  b   b   a   d
模式串T                 c  b  b  a  

在i = 7处失配，关注i = 9（b）,在模式串中找b，发现i = 6, i = 7处都有b，那应该和谁对齐？？ 应该和后面的(i = 7)处的对齐，这就是为什么要倒着在模式串中找b了，找到了直接break，并将此处与i = 9对齐。（为什么和后面的b对齐，大家思考）

下标i    0  1  2  3  4  5  6  7  8  9  10  11  12
主串S    c  b  a  b  d  c  b  a  c  b   b   a   d
模式串T                       c  b  b   a  

在i=7处失配，关注i=11（a）,匹配到模式串中最后一位为a，break；将模式串中的a与i = 17 处的 a 对齐。继续比较。

下标i    0  1  2  3  4  5  6  7  8  9  10  11  12
主串S    c  b  a  b  d  c  b  a  c  b   b   a   d
模式串T                          c  b   b   a  

匹配完成！

可见Sunday算法的核心思想就是失配时，模式串能尽可能多的向后移动，使得匹配次数减少，效率提高。

Sunday和BM不同点在于：
1. BM从后往前匹配，Sunday从前往后。
2. BM算法失配关注的是“最后一位”，Sunday关注的是“最后一位的下一位”。
3. BM有坏字符串好字符串之分，Sunday没有。(但思想比较相似，BM中的好字符 和 坏字符包含在模式串内，可以类比于Sunday算法找到了该字符；好字符和坏字符串没出现，则类比于没在模式串中找到该字符)。

代码实现：

int Sunday(const char *str1, const char *str2)
{
    int str1_len = strlen(str1);
    int str2_len = strlen(str2);
    int i = 0;
    int j = 0;
    enum{FALSE,TRUE};
    int Y = FALSE;   

    if(str1 == NULL || str2 == NULL){
    return -1;
    }

    while(i < str1_len && j < str2_len){
        if(str1[i] == str2[j]){
        i++;
        j++; 
        }else{
        //关注最后一位的后一位这个字符
        int num = i - j + str2_len ;
        for(j = str2_len-1; j >= 0; j--){
        //该字符与模式串比较，找到相同的则与该字符对齐。
        if(str1[num] == str2[j]){
            i = num - j;
                    Y = TRUE;
            break;
            }
        }
        if(Y == FALSE){
        //没找到模式串就直接跳到该字符的下一位。
        i = num + 1; 
        }
        Y = FALSE;
        j = 0;
        }
    }       
    if(i == str1_len){
    return -1;
    }else
        return i - str2_len;;
}

Sunday算法的应用价值很强，(实际效率高于KMP和BM算法)，代码实现也很简单，希望大家能够掌握。

四，KMP算法
Knuth-Morris-Pratt 字符串查找算法，简称为 “KMP算法”由Donald Knuth、Vaughan Pratt、James H. Morris三人于1977年联合发表，故取这3人的姓氏命名此算法。
KMP算法在网上说的非常麻烦，我觉得就是之前介绍的类似于BM算法的好字符后缀匹配规则，和next[]数组的推导两点而已。

算法的思想是：假设现在文本串S匹配到 i 位置，模式串P匹配到 j 位置如果j = -1(标记)，或者当前字符匹配成功（即S[i] == P[j]），都令i++，j++，继续匹配下一个字符；
如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j]。意味失配时，模式串P相对于文本串S向右移动了j - next [j] 位。换言之，当匹配失败时，模式串向右移动的位数为：失配字符所在位置 - 失配字符对应的next 值。即移动的实际位数为：j - next[j]，且此值大于等于1。

Next数组的值含义是：代表失配前的字符串中，有多大长度的相同的前缀后缀。比如Next[j] = k；表示 j 之前的字符串中有最大长度为k 的相同前缀后缀。
此也意味着在某个字符失配时，该字符对应的next 值会告诉你下一步匹配中，模式串应该跳到j-Next[j]这个位置上。所以重点在于求Next[]。

如下：
ABCDAB ABCDABC ABCDABCDABDABD 文本串
ABCDABD 模式串

最大前缀后缀相同数：

  A               左                         右                     
  AB              A                          B                      0
  ABC            A,AB                       C,BC                    0
  ABCD          A,AB,ABC                   D,CD,BCD                 0
  ABCDA        A,AB,ABC,ABCD              A,DA,CDA,BCDA             1
  ABCDAB     A,AB,ABC,ABCD,ABCDA         B,AB,DAB,CDAB,BCDAB        2
  ABCDABD   A,AB,ABC,ABCD,ABCDA,ABCDAB  D,BD,ABD,DABD,CDABD,BCDABD  0

  最大前缀后缀公共元素长度对照表
  A   B   C   D   A   B   D 
  0   0   0   0   1   2   0    

Next 数组考虑的是除当前字符外的最长相同前缀后缀，所以通过上步骤求得各个前缀后缀的公共元素的最大长度后，只要稍作变形即可：将第求得的值整体右移一位，然后初值赋为-1，如下表格所示：

 A   B   C   D   A   B   D 
-1   0   0   0   0   1   2

在匹配失配时，只需要用失配位置 j 减去 Next[j]，就可以得到模式串移动到什么位置了。

Next[]的求取代码实现如下：

int *get_next(const char* str2)
{
    int str2_len = strlen(str2);
    int *next = (int *)malloc(sizeof(int)*str2_len);
    next[0] = -1;
    int left = -1;
    int right = 0;

    while(right < str2_len - 1){
    if(left == -1 || str2[left] == str2[right]){
        left++;
        right++;
        next[right] = left;
    }else
        left = next[left];
    }
    return next;
}

这段代码是为了求取Next[]对应的值，并没有什么实际意思，能得出正确的Next[]就行(求Next[]的值，网上好像就这一种代码实现办法)。

       0   1   2   3   4   5   6 
 next -1   0   0   0   0   1   2   

我们来根据代码验证下是否准确
str_len - 1~6
left = -1
right = 0
——————————————

       0   1   2   3   4   5   6 
 next -1   0

  left = 0
  right = 1
  next[1] = 0  
--------------------------------------------
  ABCDABD
  right = 1
  left = next[0] = -1
--------------------------------------------
  left = 0
  right = 2
  next[2] = 0
      0   1   2   3   4   5   6 
next -1   0   0

可以看出是正确的(后来的就不用推演了)，代码设计的很巧妙，能恰好算出Next[]所对应的值。(这段代码不需理解，记住就行，就是为了求Next[]而专门设计的算法)。

求出Next[]的对应值，KMP算法代码就很容易了。

int KMP(const char* str1, const char* str2)
{
    int str1_len = strlen(str1);
    int str2_len = strlen(str2);
    int *next = get_next(str2); 
    int i = 0;
    int j = 0;

    if(str1 == NULL || str2 == NULL){
    return -1;
    }
    while(i < str1_len && j < str2_len){
        if(j == -1 || str1[i] == str2[j]){
            i++;
            j++;
        }else{
            //关键一步，失配时根据Next[]跳转
            j = next[j];
        }
    }
    free(next);  
    if(j == str2_len){
        return (i-str2_len);    
    }
    return -1;
}

KMP的时间复杂度：
我们发现如果某个字符匹配成功，模式串首字符的位置保持不动，仅仅是i++、j++；如果匹配失配，i 不变（即 i 不回溯），模式串会跳过匹配过的next [j]个字符。整个算法最坏的情况是，当模式串首字符位于i - j的位置时才匹配成功，算法结束。
所以，如果文本串的长度为n，模式串的长度为m，那么匹配过程的时间复杂度为-O(n)，算上计算next的-O(m)时间，KMP的整体时间复杂度为-O(m + n)。

四种经典的字符串匹配算法介绍完毕，大家在纸上多画多算，能更好的理解算法思想。