KMP 模式匹配算法的简单说明
KMP 是三位大牛:D.E.Knuth、J.H.Morris和V.R.Pratt 发明用于解决在一个主的字符串(主串)中搜索一个字符串(模式串)定位的算法。(也就是关键字搜索)
定义:主串—S 模式串—T
假设不使用KMP 模式匹配算法,我们用最简单的算法去解决 在S中搜索 T 的位置,结果就是使用暴力的方式将所有的情况进行遍历一遍
//最差时间复杂度O(n*m)
public static int simpleGetSTIndex(String s,String t){
char[] schars = s.toCharArray();//主串
char[] tchars = t.toCharArray();//模式串
int i= 0;
int j =0;
// for (i = 0;i<schars.length;){
// for (j = 0; j < tchars.length ;) {
// if(schars[i]==tchars[j]){
// i++;
// j++;
// }else{
// i=i-j+1;//回溯
// j=0;
// break;
// }
// }
// }
while (i<schars.length &&j < tchars.length ){
if(schars[i]==tchars[j]){
i++;
j++;
}else{
i=i-j+1;//回溯
j=0;
}
}
if(j==tchars.length){
//找到了
return i-j;
}else{
return -1;
}
}
上面的算法就是暴力的破解,效率很低
在研究S 和 T 我们可以分为两种情况
1. T串中的每个字符都不相等
定义: 同一时间内 i 为 S 的 遍历情况下标,j 为 T 遍历的情况下标
发现在原有的暴力破解的算法中,可以省略中间2345步骤 只需要1和6步骤,这样一来 不用回溯 i (不用做代码中 i=i-j+1;//回溯 这一个步骤) ,使得我们可以从S[i] 开始继续和T进行比较
2. T 串中有重复的字符
定义: 同一时间内 i 为 S 的 遍历情况下标,j 为 T 遍历的情况下标,k 取值[1-j-1]
发现在原有的暴力破解的算法中,可以省略中间2345步骤 只需要1和6步骤,这样一来 不用回溯 i (不用做代码中 i=i-j+1;//回溯 这一个步骤) ,此时我们可以从S[i] 和 T[j!] 处开始遍历比较。注意是j!, 为了不和在步骤1中的j 弄混,我们将其称为j!。
在观察T串中,我们发现在j 之前我们有一个从 T[1 ~ k-1] (前缀,必须包含T[1])和 T[j-k ~ j-1](后缀 必须包含最后一个字符T[j-1])的最大相同串,长度为2。而 j! = 2 + 1 (如果代码中下标从0开始,就不用加1了)。也就是说当步骤1发生S[i] != T[j] ,可以从步骤6 S[i] 和 T[j!] 开始比较
发现i 可以不用回溯,但是j得根据遍历的情况进行回溯,而j的取值是T 的长度。(读友可以试着自已验证一下是不是这样一会事)
一般问题化:发生S[i] != T[j],可以从S[i] 和 T[j!] 开始比较。而 j! 为 T[1 ~ j-1] 中最大前缀和最大后缀 相同的时候前缀或后缀的长度+1,可以用next[] 数组进行保存 j! 的取值
如何获得next 数组
定义: 同一时间内 i 为 S 的 遍历情况下标,j 为 T 遍历的情况下标,k 取值[0-j-1]
由上面的分析我们知道,next 的数组的获取基本和S没多大关系,只和T有关系,即在j处S[i] != T[j],找出T[0 ~ j-1] 中最大前缀和最大后缀的相同串并且长度小于j-1
**1. j =0,j-1<=0 ,所以令 next[0在这里插入代码片
] = -1 **
注意:求T[0 ~ j-1] 的 最大前缀后缀共同串T[0~k-1] == T[j-k ~ j-1] , next[j] = k, 可以将问题转化为在T[j-k ~ j] 中搜索 T[0 ~ k],
2.当 S[i]!=T[j],T[k] == T[j] 时
已知 :T[0~k-1] == T[j-k ~ j-1] , next[j] ==k
那么 :T[0~k-1] + T[k] == T[j-k ~ j-1] + T[j] ==》T[0~k] == T[j-k ~ j] , next[j+1] ==k+1 == next[j] +1
如下图,可以发现 next[j+1] = next[j] + 1
3. 当 S[i]!=T[j],T[k] != T[j] 时
由于是求前缀T[0~k]和后缀T[j-k ~ j-1] 的最大共同串,
因为S[i]!=T[j],T[k] != T[j]
那么可以将问题转化为在T[j-k ~ j] 中搜索 T[0 ~ k],
而T[k] != T[j] ,求T[0~k-1] 的最大前缀后缀共同串next[k]
因为k<j,所以求next[k]必然已知,
所以有 next[j] = next[k] (k<j)
具体实现
public static int[] Kmpnext(String t){
int[] next = new int[t.length()] ;
char[] tchars = t.toCharArray();
int k = -1;
int j = 0;
next[0] = -1;
while (j<tchars.length-1){
if( k==-1 ||tchars[j]==tchars[k]){
next[++j] = ++k;//已知旧数据得出新数据
}else{
k = next[k];
}
}
return next;
}
public static int KmpGetSTIndex(String s,String t){
char[] schars = s.toCharArray();//主串
char[] tchars = t.toCharArray();//模式串
int i= 0;
int j =0;
int[] kmpnext = Kmpnext(t);
while (i<schars.length){
if(j==-1 ||schars[i] == tchars[j] ){
//j==-1 代表第一个比较久不相等,i,j 都要+1
i++;
j++;
}else{
j=kmpnext[j];
}
}
if(j==tchars.length){
//找到了
return i-j;
}else{
return -1;
}
}
但是会发现有一种特殊的情况
发现 即便求了next数组简化,步骤2345也是可以省略的,这是因为T[j]==T[next[j]]
相当于在S[i] != T[j] 时 有 S[i] != T[next[j]] ,那么此时可以看成 求T[0 ~ next[j] ] 的最大前后缀
所以此时的在S[i] != T[j],T[j]==T[next[j]] 时 ,可以优化成 next[j] = next[next[j]]
public static int[] Kmpnext(String t){
int[] next = new int[t.length()] ;
char[] tchars = t.toCharArray();
int k = -1;
int j = 0;
next[0] = -1;
while (j<tchars.length-1){
if( k==-1 ||tchars[j]==tchars[k]){
++j;k++;
if(tchars[j]==tchars[k]){
next[j] = next[k];
}else{
next[j] = k;//
}
}else{
k = next[k];
}
}
return next;
}