KMP算法是非常高知名度字符串匹配算法,也非常的牛P,具体在哪呢?这个算法每次我想起来的时候,我就要看一遍,自信的觉得OK,完全掌握没问题,然后过不了几天忘得连个渣都不剩,你懂的.
先说字符串匹配算法,这个我最开始接触java的时候,这个需求可以算是入门级别的.
双重迭代,逐个匹配,直到找到完全匹配,或者主串没有足够长度.
public static int indexOf(String m, String p) {
int index = -1;
for (int i = 0; i < m.length() && m.length() - i >= p.length(); i++) {
index = i;
for (int j = 0; j < p.length(); j++) {
if (p.charAt(j) != m.charAt(i + j)) {
index = -1;
break;
}
}
if (index != -1) {
return index;
}
}
return index;
}
这种暴力迭代的算法,因为双重的for循环,导致时间复杂度为O(m*n),其实就是O(n²),
这个算法其实也是JDK中String的indexof(String)的默认算法.考虑到java中String并不是为大文本设计的,编程的String使用场景必然不会有太长的String文本,使用这种算法消耗的时间并不明显.考虑到KMP算法需要额外的开辟空间存放Next数组.所以采用了这种简单地做法.
双重for循环另一方面说,其实就是双指针,i和j的回溯.每完成一次模式串的对比,i指针就需要回到i+1的位置,j指针则回到初始位置.KMP算法的核心就是如果在完成原串和模式串的匹配后,能够不回溯i指针,这样i指针就只走一次,那么匹配的复杂度就是O(m).大神们通过利用已知模式串自身的有效信息,完成i指针不回溯,通过移动j指针,让模式串最大化的有效移动.
那么下面要做的事情比较简单,首先是如和做到i指针的不回溯,其实就是下面的推导.
T是原串,P是模式串.index是i指针这一次对比的初始位置
假如匹配的过程中
T[i] != P[j]
已知
T[index,i-1] = P[0,j-1]
假如在0和j之间有一个最大的k值使得P[0,k-1] = P[j-k,j-1]
那么必然P[0,k-1] = T[i-k, i-1]
这样下次匹配,就可以从T的i位置,P的k位置进行新的比较.
以这个公式作为出发点,下面的重点就是k的计算.
即在0和j之间寻找最大的k值,P[0,k-1] = P[j-k,j-1]这个等式的重点是则需要根据不同的j值来确定不同的k值.
k的推导过程是下边的过程
假设有P[0,k-1] = P[j-k,j-1] (Next[j] = k)
如果P[k] = P[j]
那么可以确定有P[0,k] = P[j-k,j],即Next[j + 1] = k + 1
如果P[k] != P[j]
那么必然可以确定不存在一个大于k的k2值,使得前面的公式P[0,k-1] = P[j-k,j-1]成立.
只能从小于k的子集中查找.
又可以知道k' = Next[k]的值,
也符合P[0,k' -1] = P[k-k' ,k-1],
如果此时存在P[k']==P[j],
那么Next[j+1] = k'+1
这里还需要注意的是求k'这其实是一个递归的过程,因为需要一直递归k前边的子串使得确定不存在k'的值(这里真的相当难理解)
这样通过一次循环既可以推得所有的Next数组.
所以Next数组的求解方案:
private static int[] getNext(String p) {
int[] next = new int[p.length()];
next[0] = -1;
int k = -1;
int j = 0;
while (j < p.length() - 1) {
if (k == -1 || p.charAt(k) == p.charAt(j)) {
next[++j] = ++k;// 如果k位置的值和当前位置的值相等,那么当前位置的next[cur] = k + 1
} else {
k = next[k];// 找到k'
}
}
next[0] = 0;
return next;
}
在有了next数组的基础上,按照上面所述,只需要单次移动i指针就可以完成模式串的匹配查找.因为需要优先计算Next数组,所以,这个算法的复杂度就是O(m+n),不过也多了O(n)的空间.
public static int kmpIndexOf(String m, String p) {
int index = -1;//记录第一个匹配的位置
final int[] next = getNext(p);
int i = 0;//记录原串的i指针,也是下一次匹配时,原串的初始位置
int k = next[i];//下一次匹配时,模式串的初始位置
//跳出循环的条件,原串的剩余部分不够模式串长度
while (i < m.length() && m.length() - i >= p.length()) {
index = i;//记录当前的位置
for (int j = k; j < p.length(); j++) {
i++;//原串单次循环,只要经过一次对比,i指针往前一步
k = next[j];//更新k值,为下一次P串的初始位置.
if (p.charAt(j) != m.charAt(index + j)) {//发现不等,跳出开始从i指针的记录位置,重新匹配.
index = -1;
break;
}
}
if (index != -1) {//匹配完成,全部相等,跳出.返回index
return index;
}
}
return index;
}
其实写了这些我也不太会贴图,深感词不达意,也不能说自己完全掌握的明明白白.不过,我也试过,无论我看过多少关于KMP算法的文章,也都感觉不能完全理解.直到自己手动写的时候,去自己思考的时候,就很容易理解了.说白了,看的迷糊没事儿,写一遍就OK.
这也是要写这篇文章的目的,让自己在思考一遍.坦白说,就是自己写给自己看的,也希望过两天我自己还能看得懂.
