用erlang写的kmp算法

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

KMP算法对比暴力匹配算法的优势是：KMP算法通过分析模式串，找出模式串中相同的前缀和后缀，这样在匹配失败，移动模式串的时候，避免一些重复性的工作。

KMP算法的流程是：

• 文本串S匹配到位置i，模式串P匹配到位置j
  • 如果j == -1，或者当前字符匹配成功，即S[i] == P[j]，令i++，j++，继续匹配下一个字符
  • 如果j != -1，且当前字符不匹配，即S[i] != P[j]，令i不变，j = next[j]。
    
    可以看出，kmp算法的关键在于计算出Next数组。

next数组对应的是模式串P。对next数组计算过程的理解，类似于归纳分析法。next数组中每一个元素的值，表示模式串P中该元素对应的字符前面的子字符串（不包括该位置的字符）中相同的前缀和后缀的长度。

令

next[0] = -1

next[j] = k

• 如果P[k] == P[j]，则next[j+1] = next[j] + 1 = k + 1
• 如果P[k] != P[j]，进行递归运算，如果P[next[k]] == P[j]，则next[j + 1] = next[k] + 1，否则继续递归。

这是c版本的，别人的：

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;
}
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])
        {
            ++k;
            ++j;
            next[j] = k;
        }
        else
        {
            k = next[k];
        }
    }
}

我自己写了一个Erlang版本的：

-module(kmp).
-compile([export_all]).
  get_next(Pattern) ->
      Next = [-1],
      K = -1,
      J = 0,
      do_while(K, J, Next, Pattern).
  do_while(_K, J, Next, Pattern) when J >= length(Pattern) - 1->
      Next;
  do_while(K, J, Next, Pattern) ->
      case K =:= -1 orelse lists:nth(J + 1, Pattern) =:= lists:nth(K + 1, Pattern) of
          true ->
             K1 = K + 1,
             J1 = J + 1,
             NewNext = lists:append(Next, [K1]),
             do_while(K1, J1, NewNext, Pattern);
         false ->
             K1 = lists:nth(K + 1, Next),
             do_while(K1, J, Next, Pattern)
      end.
  kmpSearch(String, Pattern) ->
      SLen = length(String),
      PLen = length(Pattern),
      Next = get_next(Pattern),
      {SEnd, PEnd} = do_search(0, 0, SLen, PLen, String, Pattern, Next),
      Index = if PEnd =:= PLen ->
                  SEnd - PEnd;
                 true ->
                     -1
              end,
      Index.
  do_search(I, J, SLen, PLen, String, Pattern, Next) when I < SLen , J < PLen ->
      case J =:= -1 orelse lists:nth(I + 1, String) =:= lists:nth(J + 1, Pattern) of
          true ->
              I1 = I + 1,
              J1 = J + 1,
              do_search(I1, J1, SLen, PLen, String, Pattern, Next);
          false ->
              J1 = lists:nth(J + 1, Next),
              do_search(I, J1, SLen, PLen, String, Pattern, Next)
      end;
  do_search(I, J, _SLen, _PLen, _String, _Pattern, _Next) ->
      {I, J}.

参考：

• http://blog.csdn.net/v_july_v/article/details/7041827
• http://www.jianshu.com/p/e2bd1ee482c3
• http://www.jianshu.com/p/9d068872913e