模式匹配算法总结

本文参考：
1. http://blog.csdn.net/tukangzheng/article/details/38438481
2. 《算法导论》

模式匹配：子串在主串中的定位

设S为目标串（主串），P为模式串（子串），且不妨设：

S="s0s1s2...sn-1"
P="t0t1t2...tm-1"

1. 暴力匹配算法

串的匹配实际上是对合法位置0<=i<=n-m依次将目标串中的子串S[0…m-1]和模式串P[0…m-1]进行比较：

• 若S[0…m-1]=P[0…m-1]，则称从位置i开始的匹配成功。
• 若S[0…m-1]！=P[0…m-1]，从i开始的匹配失败。

位置i称为位移，匹配成功则i为有效位移，匹配失败则i为无效位移。

//若匹配成功，则返回位置；失败则返回-1.
int ViolentMatch(char* s, char* p)  
{  
    int sLen = strlen(s);  
    int pLen = strlen(p);  

    int i = 0;  
    int j = 0;  
    while (i < sLen && j < pLen)  
    {  
        if (s[i] == p[j])  
        {  
            //①如果当前字符匹配成功（即S[i] == P[j]），则i++，j++      
            i++;  
            j++;  
        }  
        else  
        {  
            //②如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0      
            i = i - j + 1;  
            j = 0;  
        }  
    }  
    //匹配成功，返回模式串p在文本串s中的位置，否则返回-1  
    if (j == pLen)  
        return i - j;  
    else  
        return -1;  
}  

2. KMP算法

2.1 定义:

Knuth-Morris-Pratt 字符串查找算法，简称为 “KMP算法”，常用于在一个文本串S内查找一个模式串P 的出现位置。
这个算法由Donald Knuth、Vaughan Pratt、James H. Morris三人同时独立发现，后取这3人的姓氏命名此算法。

其改进在于：
每当一趟匹配过程出现字符不相等时，主串指示器不用回溯，而是利用已经得到的“部分匹配”结果，将模式串的指示器向右“滑动”尽可能远的一段距离后，继续进行比较。

2.2 具体算法：

• 假设现在文本串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 值（next 数组的求解会在下文详细阐述），即移动的实际位数为：j - next[j]，且此值大于等于1。

int KmpSearch(char* s, char* p)  
{  
    int i = 0;  
    int j = 0;  
    int sLen = strlen(s);  
    int pLen = strlen(p);  
    while (i < sLen && j < pLen)  
    {  
        //①如果j = -1，或者当前字符匹配成功（即S[i] == P[j]），都令i++，j++      
        if (j == -1 || s[i] == p[j])  
        {  
            i++;  
            j++;  
        }  
        else  
        {  
            //②如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j]      
            //next[j]即为j所对应的next值        
            j = next[j];  
        }  
    }  
    if (j == pLen)  
        return i - j;  
    else  
        return -1;  
}  

2.3 next数组

已知next [0, …, j]，如何求出next [j + 1]呢？
对于pattern的前j+1个序列字符：

• 若pattern[k] == pattern[j]，则next[j + 1 ] = next [j] + 1 = k + 1
• 若pattern[k ] ≠ pattern[j]，如果此时pattern[ next[k] ] == pattern[j ]，则next[ j + 1 ] = next[k] + 1，否则继续递归重复此过程。 相当于在字符p[j+1]之前不存在长度为k+1的前缀”p0 p1, …, pk-1 pk”跟后缀“pj-k pj-k+1, …, pj-1 pj”相等，那么是否可能存在另一个值t+1 < k+1，使得长度更小的前缀 “p0 p1, …, pt-1 pt” 等于长度更小的后缀 “pj-t pj-t+1, …, pj-1 pj” 呢？如果存在，那么这个t+1 便是next[ j+1]的值，此相当于利用next 数组进行P串前缀跟P串后缀的匹配。

void GetNext(char* p,int next[])  
{  
    int pLen = strlen(p);  
    next[0] = -1;  
    int k = -1;  
    int j = 0;  
    while (j < pLen - 1)  
    {  
        //p[k]表示前缀，p[j]表示后缀  
        if (k == -1 || p[j] == p[k])   
        {  
            ++j;  
            ++k;  
            next[j] = k;  
        }  
        else   
        {  
            k = next[k];  
        }  
    }  
}