对应leetcode 28题~
动机
朴素的串匹配方法复杂度为 O ( m n ) O(mn) O(mn)。
而其中包含一些不必要的匹配检查,能否通过已经匹配了的部分抽取一些信息,减少不必要的匹配呢?
Next数组的值
N e x t [ k ] Next[k] Next[k]表示模式串 P [ 1 … k ] P[1\dots k] P[1…k]的最长相同前后缀长度。
当发现主串 T [ i ] T[i] T[i]和 P [ k ] P[k] P[k]出现不匹配时,KMP算法将模式串P向后滑动,下一步让主串 T [ i ] T[i] T[i]和 P [ n e x t [ k − 1 ] ] P[next[k-1]] P[next[k−1]]进行匹配。
即实际上是从模式串 P [ 1 … k − 1 ] P[1\dots k-1] P[1…k−1]相同前后缀的下一个字符开始,与 T [ i ] T[i] T[i]继续进行匹配。
以next为2和4的情况进行示例,next越大,P往后滑动的距离其实越少:
为什么是相同前后缀?假设出现匹配失败:
设主串为T,模式串为P, T [ 0 … i − 1 ] T[0\dots i-1] T[0…i−1]与 P [ 0 … j − 1 ] P[0\dots j-1] P[0…j−1]匹配,在 T [ i ] T[i] T[i]与 P [ j ] P[j] P[j]匹配失败。
假设我们下一步要将
P
[
k
]
P[k]
P[k]与
T
[
i
]
T[i]
T[i]进行匹配,若希望
P
[
0
,
…
,
k
−
1
]
P[0,\dots,k-1]
P[0,…,k−1]与
T
[
i
−
k
,
…
,
i
−
1
]
T[i-k,\dots,i-1]
T[i−k,…,i−1]能匹配上。应满足:
P
[
0
…
k
−
1
]
=
P
[
j
−
k
,
…
,
j
−
1
]
P[0\dots k - 1] = P[j -k, \dots, j- 1]
P[0…k−1]=P[j−k,…,j−1]
下面这张图是理解的关键:
假设已经得到了next数组:
public int strStr(String haystack, String needle) {
if ("".equals(haystack) || "".equals(needle)) {
return -1;
}
char[] T = haystack.toCharArray();
char[] P = needle.toCharArray();
int[] next = getNextArray(P);
int i = 0;
int j = 0;
// 模式串P还没有走完,还没有匹配成功
// 主串T还没有走完,还有希望
while (i != haystack.length() && j != needle.length()) {
if (T[i] == P[j]) {
i++;
j++;
}
else {
// 模式串的第一个字符就莫得匹配上哦,糟糕,把i后移一位试试看吧
if (j == 0) {
i++;
}
else {
// 不是从头开始让j=0,i++
// 而是可以从i和next[j-1]的位置继续匹配
j = next[j - 1];
}
}
}
// P走完惹
if (j == needle.length()) {
return i - j;
}
return -1;
}
怎么得到Next数组?
设 n e x t [ i ] next[i] next[i]表示串 P [ 0 … i ] P[0\dots i] P[0…i]的最长相同前后缀。
若 n e x t [ 0 … i − 1 ] next[0\dots i-1] next[0…i−1]已知,可递推得到 n e x t [ i ] next[i] next[i]:
- k = n e x t [ i − 1 ] k=next[i-1] k=next[i−1]
- 如果 P [ k ] = P [ i ] P[k]=P[i] P[k]=P[i], n e x t [ i ] = k + 1 next[i]=k+1 next[i]=k+1,计算结束
- 否则:
- 如果 k > 0 k > 0 k>0,令 k = n e x t [ k − 1 ] k=next[k-1] k=next[k−1],转向步骤2
- 如果 k = 0 k=0 k=0, n e x t [ i ] ← P [ 0 ] = P [ i ] ? 1 : 0 next[i] \leftarrow P[0]=P[i]\ ?\ 1 : 0 next[i]←P[0]=P[i] ? 1:0;
解释如下:
理解的关键在于 P [ 0 … k − 1 ] P[0\dots k-1] P[0…k−1]的最长相等前缀一定为 P [ 0 … i − 1 ] P[0\dots i-1] P[0…i−1]的相等前缀。
下图中蓝色圆圈内的数字表示进行比较。
public int[] getNextArray(char[] pattern) {
int[] next = new int[pattern.length];
// 初始化
next[0] = 0;
// 递增设置next[i]
for (int i = 1; i < next.length; i++) {
int k = i;
while (true) {
// 找到 P[0,...,k-1]的最长公共前后缀位置
k = next[k - 1];
// 判断该公共前后缀能否再加入pattern[i]
if (pattern[k] == pattern[i]) {
next[i] = k + 1;
break;
}
// 判断k是否为0,若为0可直接退出,上面已检查过pattern[0]与pattern[i]是否相等
if (k == 0) {
next[i] = 0;
break;
}
}
}
return next;
}