实现indexOf算法
朴素算法就是最容易想到的算法,例如ababc和abc进行匹配,第一次匹配时,两个指针分别在src[2]和p[2]适配,模式串回退到0的位置,而源串回退到src[1]即从匹配起始位置的下一个位置重新比较。时间复杂度是(m * n),其中m和n分别是两个字符串的长度。
public int strStr(String src, String pattern) {
if(pattern.length()==0)return 0;
if(src.length()==0)return -1;
int i =0;
int j =0;
while (i<src.length()&&j<pattern.length()){
if(src.charAt(i)==pattern.charAt(j)){
i++;
j++;
}else {
i=i-j+1;
j=0;
}
}
if(j==pattern.length()){
return i-pattern.length();
}else {
return -1;
}
}
KMP算法的核心是构造next数组,这个数组next[i]表示s[0…i]中前后缀的最长的公共长度。
例如字符串aabaaab的next数组值分别为 0 1 0 1 2 2 3 ,其中数组的第一个元素一定是0。
生成next数组
现在,我们先不考虑如何求出这个next数组,只考虑有了这个next数组可以做什么?这个next是在模式串上构造出来的,但是由于这是匹配算法,如果源串和模式串能够匹配部分串,当发生某个位置的失配并进行移动的时候,是能够在源串上用上这个数组的。
public int strStr(String haystack, String needle) {
if(haystack.equals(needle))return 0;
if(needle.equals(""))return 0;
if(haystack.equals(""))return -1;
int[] next = getNext(needle);
int i=0;int j=0;
while (i<haystack.length()){
while (j-1>=0&&haystack.charAt(i)!=needle.charAt(j))j=next[j-1];
if(haystack.charAt(i)==needle.charAt(j))j++;
if(j==needle.length())return i-needle.length()+1;
i++;
}
return -1;
}
使用了next数组的字符匹配算法,也是双指针变量,当发生失配的时候,源串指针不移动,模式串的指针进行回退。
例如:源串abababcaba ,模式串ababc,其中src[4]和p[4]将失配,其中abab的next数组的值为[0,0,1,2],模式串不会向朴素算法那样一次性退回到1(0的下一个位置),而是退回到第2个位置。(回溯是写在循环里面的,因此有可能最终退化为朴素)(这个2可以理解为,前缀的两个元素ab和后缀相同,因此直接从2个元素的下一个位置,即0、1的下一个位置2开始重新匹配)。于是第二轮ababc和从第二个位置和abababacba进行匹配,最终可以成功匹配。
假设next[i]=2,指的是s[0…i]的最长公共前后缀长度是2,即前面0、1和i、i-1对应的元素相同,如果回退将模式串的指针回退到第2个元素后面的哪一个元素即可(0和1位置元素下一个位置2对应的元素)
让模式串自己和自己做匹配得到,得到next。写法和next使用很像。其中p[0…i]看作两个逻辑子串,计算前后缀的过程其实就是匹配这两个逻辑子串的过程。
private int[] getNext(String p){
int len = p.length();
int[] next = new int[len];
next[0]=0;
int j=0;
for (int i = 1; i < len; i++) {
while (j-1>=0&&p.charAt(j)!=p.charAt(i)){
j=next[j-1];
}
if(p.charAt(j)==p.charAt(i)){
j++;
}
next[i]=j;
}
return next;
}
后话:KMP挺难理解,博主也是大概有个思路,这里仅仅作为总结。代码比较简洁明了,应该挺好记的。