概述:实现KMP模式匹配算法
KMP算法:串的模式匹配指的是在主串中查找模式串的过程,主要有Brute-Force算法和KMP算法
Brute-Force算法:
Brute-Force算法是最简单的暴力查找,它从主串的第一个字符开始和模式串的第一个字符进行比较,如果相等,则继续比较后续字符;否则从主串的第二个字符开始和模式串重复前一步操作,直到模式串的所有字符都和主串匹配上。
KMP算法:
Brute-Force算法效率很低,原因在于对于某些字符做了很多次重复的比较,如果主串长度为m,模式串长度为n,最坏的情况下,时间复杂度为O(m×n)。
KMP算法是利用了部分匹配的结果,跳过重复的比较,具体做法是将指向模式串的下标移动一定的步数。通过分析后可以发现,当某一个位置匹配失败时,需要跳过的位数只和模式串有关,由此可以得到模式串对应的next数组,在模式串和主串匹配过程中,当匹配失败时,根据next数组即可得到模式串下一次需要指向的位置。
KMP算法的大致分为两块:求解模式串的next数组的函数;根据next数组进行匹配得到匹配结果。
next数组:
要得到next数组,我们先了解一下字前缀和后缀的概念:前缀是指除了最后一个字符外的字符串的全部以第一个字母开头的(真)子串;后缀是指除了第一个字符外的字符串的全部以最后一个字符结尾的(真)子串。
我们先求出“最大长度数组”,“最大长度就是”前缀和后缀的最长的共有元素的长度。以"ABCDABD"为例:
- "A"的前缀和后缀都为空集,共有元素的长度为0;
- "AB"的前缀为[A],后缀为[B],共有元素的长度为0;
- "ABC"的前缀为[A, AB],后缀为[BC, C],共有元素的长度0;
- "ABCD"的前缀为[A, AB, ABC],后缀为[BCD, CD, D],共有元素的长度为0;
- "ABCDA"的前缀为[A, AB, ABC, ABCD],后缀为[BCDA, CDA, DA, A],共有元素为"A",长度为1;
- "ABCDAB"的前缀为[A, AB, ABC, ABCD, ABCDA],后缀为[BCDAB, CDAB, DAB, AB, B],共有元素为"AB",长度为2;
- "ABCDABD"的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB],后缀为[BCDABD, CDABD, DABD, ABD, BD, D],共有元素的长度为0。
所以“最大长度数组”是[0, 0, 0, 0, 1, 2, 0]
next数组是将“最大长度数组”往后移一位,并将第一个元素赋值为-1
得到匹配结果:
如果模式串的第一个字符就匹配失败,或者字符匹配成功,则模式串和主串的下标都+1;若模式串部分匹配,则模式串的下标j=next[j]
实现思路:
在求next数组的时候,我们可以发现,前缀后缀的共有元素,其第一个字符必定与模式串第一个字符相等,其最后一个字符与后缀最后一个字符相等(后面这个条件在实现时并没有用到)。
实现:
public class KMP {
/**
* 返回模式串在主串中第一次出现的起始位置
*
* @param string
* 主串
* @param subString
* 模式串
* @return 模式串在主串中第一次出现的起始位置
*/
public int find(String string, String subString) {
if (string == null || string.length() == 0 || subString == null
|| subString.length() == 0) {
return -1;
}
int[] next = getNext(subString);
int i = 0;
int j = 0;
while (i < string.length()) {
// 模式串的第一个字符就不匹配,或者对应字符匹配,主串和模式串的下标都往后移一位
if (j == -1 || string.charAt(i) == subString.charAt(j)) {
i++;
j++;
} else {
j = next[j];
}
// 如果匹配到了,就返回模式串在主串中第一次出现的起始位置
if (j == subString.length()) {
return i - j;
}
}
return -1;
}
/**
* 获取next数组
*
* @param subString
* 模式串
* @return next数组
*/
private int[] getNext(String subString) {
// 入参校验
if (subString == null || subString.length() <= 1) {
return new int[]{-1};
}
int length = subString.length();
int[] next = new int[length];
// 第一个元素设置为0
next[0] = 0;
// 得到最大长度数组
for (int index = 1; index < length; index++) {
// 每次开始找对应位的最大长度时,将前缀和后缀下标重置为起始位置
next[index] = getMaxPubStr(subString.substring(0, index),
subString.substring(1, index + 1));
}
// 得到next数组(将数组元素后移一位,第一个元素赋值为-1)
for (int k = next.length - 1; k > 0; k--) {
next[k] = next[k - 1];
}
next[0] = -1;
return next;
}
/**
* 获取最大公共子串长度
*
* @param pre
* 前缀
* @param suf
* 后缀
* @return 最长子串长度
*/
private int getMaxPubStr(String pre, String suf) {
int len = pre.length();
int index = len;
String subPre = "";
String subSuf = "";
while (index > 0) {
subPre = pre.substring(0, index);
subSuf = suf.substring(len - index);
if (subPre.equals(subSuf)) {
break;
}
index--;
}
return index;
}
}
参考文章:
https://blog.csdn.net/buaa_shang/article/details/9907183
https://blog.csdn.net/v_JULY_v/article/details/7041827