KMP字符串匹配算法

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];  
        }  
    }  
}  

行文至此，咱们全面了解了暴力匹配的思路、KMP算法的原理、流程、流程之间的内在逻辑联系，以及next 数组的简单求解（《最大长度表》整体右移一位，然后初值赋为-1）和代码求解，最后基于《next 数组》的匹配，看似洋洋洒洒，清晰透彻，但以上忽略了一个小问题。

    比如，如果用之前的next 数组方法求模式串“abab”的next 数组，可得其next 数组为-1 0 0 1（0 0 1 2整体右移一位，初值赋为-1），当它跟下图中的文本串去匹配的时候，发现b跟c失配，于是模式串右移j - next[j] = 3 - 1 =2位。

    右移2位后，b又跟c失配。事实上，因为在上一步的匹配中，已经得知p[3] = b，与s[3] = c失配，而右移两位之后，让p[ next[3] ] = p[1] = b 再跟s[3]匹配时，必然失配。问题出在哪呢？

    问题出在不该出现p[j] = p[ next[j] ]。为什么呢？理由是：当p[j] != s[i] 时，下次匹配必然是p[ next [j]] 跟s[i]匹配，如果p[j] = p[ next[j] ]，必然导致后一步匹配失败（因为p[j]已经跟s[i]失配，然后你还用跟p[j]等同的值p[next[j]]去跟s[i]匹配，很显然，必然失配），所以不能允许p[j] = p[ next[j ]]。如果出现了p[j] = p[ next[j] ]咋办呢？如果出现了，则需要再次递归，即令next[j] = next[ next[j] ]。

class KMP {
	public static int[] GetNext(string str) {
		int length = str.Length;
		int[] next = new int[length];
		next[0] = -1;
		int k = -1;
		int j = 0;
		while (j < length - 1) {
			if (k == -1 || str[j] == str[k]) {
				++j;
				++k;
				if (str[j] != str[k]) {
					next[j] = k;
				} else {
					next[j] = next[k];
				}
			} else {
				k = next[k];
			}
		}
		return next;
	}
}

public static int Search(string str, string pat) {//搜索第一个匹配位置
	int i = 0, j = 0;
	int[] next = KMP.GetNext(str);
	while (i < str.Length && j < pat.Length) {
		if (j == -1 || str[i] == pat[j]) {
			j++;
			i++;
		} else {
			j = next[j];
		}
	}
	if (j == pat.Length) {
		return i - j;
	} else {
		return -1;
	}
}

static public IList<int> Search(string s, string p) {//搜索所有匹配位置
	List<int> result = new List<int>();
	int[] next = KMP.GetNext(s);
	int j = 0;
	int i = 0;
	while (i < s.Length) {
		while (i < s.Length && j < p.Length) {
			if (j == -1 || s[i] == p[j]) {
				j++;i++;
			} else {
				j = next[j];
			}
		}
		if (j == p.Length) {
			result.Add(i - j);
			i = (i - j) + p.Length;
			j = next[j];
		}
	}
	return result;
}