C#算法系列（11）——KMP模式匹配算法

       今天要实现的这个算法是在复习串操作时出现的，之前看过一遍，但时隔久远，毫无印象，捡起来还有点儿困难，发现当时理解不是那么透彻，自己主要理解难点是这个算法如何求解next数组。明白之后，发现它也并不难理解，就是有些资料的术语起了误导的作用，下面会按照小白的思路进行一系列说明，力求道明它的本质。

一、KMP算法背景

       主要是要解决求解子串在主串中第一次出现位置的问题，KMP的提出能使得这个求解过程效率得到提升。下面看一下使用串的基本操作来实现这个功能。代码如下：

//若主串S中第pos个字符之后存在与T相等的子串
//则返回第一个与子串T相同的在主串S中的位置，否则返回0
public int IndexOfStr(string S, string T,int pos)
{
    int n = S.Length, m = T.Length, i = pos;
    string sub;
    if (pos >= 0)
    {
        while (i <= n - m + 1)
        {
            //取出主串第i个位置长度与T相等子串给sub
            sub = S.Substring(i,m);
            if (sub != T)
                ++i;
            else
                return i;
        }
    }
    return -1;
}

       上述代码使用了，求字符串长度、字符串取子串以及字符串比较等基本操作。下面将单纯用数组来实现同样的功能，这种被称为朴素的模式匹配，主要思路如下：将子串的字符挨个与主串的字符比较，若相同，则进行下一个字符比较；若不相同，则主串的迭代变量回退到上次能够匹配的下一位置，而子串的迭代变量回到首位。代码如下：

/// <summary>
/// 返回子串在主串中的索引
/// </summary>
/// <param name="s">主串</param>
/// <param name="t">子串</param>
/// <returns></returns>
/// 最坏的时间复杂度为O（（n-m+1）*m）
public int IndexString(string s, string t)
{
    int i=0,j=0;//i,j,分别指向S,T串中，当前下标位置
    //j<t.Length的作用在于只检测一次子串，即返回第一个与主串发生匹配
    while (i < s.Length && j < t.Length)
    {
        //挨个字符匹配
        if (s[i] == t[j])
        {
            ++i;
            ++j;
        }
        //不匹配，则i，j回退
        else
        {
            i = i - j + 1;//i退回到上次匹配首位的下一位
            j = 0;//j退回到子串T的首位
        }
    }
    if (j >= t.Length)
        return i - t.Length;//返回子串在主串中的第一个起始位置
    else
        return -1;
}

       但是，i = i-j+1这样回退，会导致出现重复匹配的过程，导致效率降低。比如：主串S为”abcdefgab…”, 子串T为“abcdex”，当主串i=2、3、4、5、6(下标从1开始)时,主串的首字符与子串的首字符均不等。仔细观察发现，对于要匹配的子串T来说，”abcdex”首字母“a”与后面的串“bcdex”中任意一个字符都不相等。若子串的前五位与主串的前五位相等，如步骤1，意味着子串T的首字符“a”不可能与S串的第2位到第5位的字符相等，因此上图2,3,4,5步判断就是多余的，因此主串的迭代变量是可以保持不变。

       上面的重复性是主串的迭代变量重复，下面在来看另外一个例子，主串S=”abcababca”，子串T = “abcabx”。对于开始的判断，前5个字符完全相等，第6个字符不等。此时，根据刚才的经验，T的首字符“a”与T的第二位字符“b”、第三位字符“c”均不等，所以不需要做判断，因此当主串i=2,3时，判断就是多余的。 关键的地方来了，T的首位“a”与T的第四位“a”相等，第二位“b”与第五位“b”相等。而在步骤1时，T串的第四位“a”与第五位“b”已经与主串S中相应位置比较过了是相等的，因此可以断定，T首字符“a”、第二位字符“b”与S的第四位字符和第五位字符也不需要比较，肯定也相等了，所以步骤4,5这两步也可以省略。

       KMP模式匹配就是为了减少这种没必要的重复性比对操作。因此在保持主串的迭代变量i值不回溯，也就是不可以变小，则需要变化的就是子串的迭代变量j值。j值的变化也是有规律的。j值的多少取决于当前字符的串的 真前后缀的相似度。于是，j值的变化定义了一个数组next来进行描述了，那么next的长度的长度就是T串的长度。next数组函数定义如下：

二、next数组值推导

       以子串“ababaaaba”为例，有如下表：

       当j=0时，next[0] = 0（此时下标从0开始）;当j=1,2时，next[1]=next[2]=1(属于其它情况);
       当j=3时，j有0到2的串是，“aba”，前缀字符“a”,与后缀字符“a”相等，next[3]=1+1=2;
       当j=4时，j有0到3的串是，“abab”，前缀字符“ab”,与后缀字符“ab”相等，next[4]=2+1=3;
       当j=5时，j有0到4的串是，“ababa”，前缀字符“aba”,与后缀字符“aba”相等，next[5]=3+1=4;
       当j=6时，j有0到5的串是，“ababaa”，前缀字符“ab”,与后缀字符“aa”不相等，next[6]=1+1=2;
       当j=7时，j有0到6的串是，“ababaaa”，只有前缀字符“a”,与后缀字符“a”相等，next[7]=1+1=2;
       当j=8时，j有0到7的串是，“ababaaab”，只有前缀字符“ab”,与后缀字符“ab”相等，next[8]=2+1=3;
       因此， 我们可以根据经验得到，如果前后缀有n个相等的k值，就是n+1。这里的前后缀为真前后缀，即不包括自身的子串。

三、KMP算法实现过程

        KMP算法的提出就是解决这种重复匹配的过程。也是在上述朴素模式匹配算法的基础上修改得到的，下来面看下next的实现。
（1）实现得到next数组，代码如下：

//计算next数组
//next数组含义，子串的最长前缀和最长后缀相同的长度+1（+1的原因，在于相同的字符串的下一个位置）
//next数组的每个值，即是对应位置下次往前移动的距离
private void GetNext(string T,int[] next)
{
    int i = 0, j = 0; //i为串T的迭代时的下标，j为子串的相同部分的数量+1
    next[0] = 0;
    while ((i+1) < T.Length)
    {
        //T[i]表示后缀的单个字符，T[j]表示前缀的单个字符
        if (j == 0 || T[i] == T[j-1])
        {
            ++i;
            ++j;
            next[i] = j;
        }
        //当前字符比较不同，j根据next表值进行回溯
        //回溯的目的是为了找到上一次相同的字符位置，来确定当前i位置对应的n
        else
            //此时的j值，在上一轮判断中自动后移了，而next数组对应的位置从0开始，因此下标需要减1；若next数组从1开始，则此处不需要减1
            j = next[j-1];
    }
}

       再来看下代码中是如何实现回溯的，过程如下图：

       看到这里的时候，不由得感慨写出这段代码的人编程内功深厚，佩服佩服！！！以上纯属个人感概，不喜勿喷，谢谢^_^.下面我们在再看看下子串在主串位置的主逻辑，代码如下，与朴素模式匹配基本一致。

public int Index_KMP(string S,string T)
{
   int i = 0, j = 0; //i为主串的迭代变量，j为子串迭代变量
   int[] next = new int[T.Length];
   //计算next数组
   GetNext(T,next);
   while (i < S.Length && j < T.Length)
   {
       //两字母相等则继续
       if (j == 0 || S[i] == T[j])
       {
           ++i;
           ++j;
       }
       //指针后退重新开始匹配
       else
       {
           //j根据next数组回退到合适的位置，i值不变
           //此时的j值，在上一轮判断中自动后移了，而next数组对应的位置从0开始，因此下标需要减1；若next数组从1开始，则此处不需要减1
           j = next[j-1];
       }
   }
   if (j >= T.Length)
       return i - T.Length;
   else
       return -1;
}

       此时，上述代码就是去掉了i值回溯的部分，其余与朴素算法一样。对于get_next函数来说，若T的长度为m,因此只设计到简单的单循环，时间复杂度为O(m)，Index_KMP的i值不回溯之后，while的时间复杂度为O（n）。因此，整个算法时间复杂度为O(n+m)。相比较朴素模式匹配算法O（（n-m+1）*m）来说，是要好些。这里需要强调的是，KMP算法仅当模式与主串之间存在许多“部分匹配”的情况下才会体现出它的优势，否则二者差异不明显。

四、KMP算法改进

       改进其实也是针对于next数组改进。目前还存在如下问题：

       这当中的第2，3，4，5步骤，其实都是多余的。由于T串的第2，3，4，5位置的字符都与首位的“a”相等，那么可以用首位next[0]的值去取代与它相等的字符后续next[j]的值。于是GetNext函数代码修改后如下：

//对上述计算next移动数组的优化
private void GetNextVal(string T, int[] next)
{
    int i = 0, j = 0;
    next[0] = 0;
    while ((i + 1) < T.Length)
    {
        if (j == 0 || T[i] == T[j - 1])
        {
            ++i;
            ++j;
            //若当前字符与前缀字符不同
            if (T[i] != T[j - 1])
                //当前j为next在i位置上的值
                next[i] = j;
            else
                next[i] = next[j - 1];
        }
        else
            j = next[j - 1];
    }
}

五、实验结果

       主函数测试代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace KMP_模式匹配
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = "googlegood";
            string t = "google";
            Console.WriteLine("字符串t:"+t+"在字符串s："+s+"中的位置在第几个？");
            //传统方法
            int pos1 = KMP_Test.Instance.IndexOfStr(s,t,0);
            Console.WriteLine("传统方法求解：" + (pos1 + 1));
            //朴素的模式匹配（即未优化匹配项）
            int pos2 = SimpleKMP.Instance.IndexString(s,t);
            Console.WriteLine("朴素模式匹配求解：" + (pos2+1));
            //KMP算法
            int pos3 = KMP_Test.Instance.Index_KMP(s,t);
            Console.WriteLine("KMP算法求解：" + (pos3 + 1));
            Console.ReadKey();
        }
    }
}

       实验截图：

       以上，就是本次KMP算法的讲解，如有疑问，欢迎留言！谢谢浏览！！！