KMP算法的实现与解析

最新推荐文章于 2024-03-25 08:34:11 发布

你走吧起风了__

最新推荐文章于 2024-03-25 08:34:11 发布

阅读量173

点赞数

分类专栏：数据结构与算法专辑文章标签：算法字符串 java 数据分析

本文链接：https://blog.csdn.net/m0_46405589/article/details/112711259

版权

数据结构与算法专辑专栏收录该内容

49 篇文章 0 订阅

订阅专栏

KMP 算法介绍

KMP是一个解决模式串在文本串是否出现过，如果出现过，最早出现的位置的经典算法
Knuth-Morris-Pratt 字符串查找算法，简称为 “KMP算法”，常用于在一个文本串S内查找一个模式串P的出现位置，这个算法由Donald Knuth、Vaughan Pratt、James H. Morris三人于1977年联合发表，故取这3人的姓氏命名此算法.
KMP方法算法利用之前判断过信息，通过一个next数组，保存模式串中前后最长公共子序列的长度，每次回溯时，通过next数组找到，前面匹配过的位置，省去了大量的计算时间

参考资料：https://www.cnblogs.com/ZuoAndFutureGirl/p/9028287.html

KMP 算法流程

举例来说，有一个字符串 Str1 = “BBC ABCDAB ABCDABCDABDE”，判断，里面是否包含另一个字符串 Str2 = “ABCDABD”？
首先，第一步用Str1的第一个字符和Str2的第一个字符去比较，不符合，关键词向后移动一位

重复第一步，还是不符合，再后移

一直重复，直到Str1有一个字符与Str2的第一个字符符合为止

接着比较字符串和搜索词的下一个字符，还是符合

遇到Str1有一个字符与Str2对应的字符不符合

这时候，想到的是继续遍历Str1的下一个字符，重复第1步

其实是很不明智的，因为此时BCD已经比较过了，没有必要再做重复的工作，一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是”ABCDAB”
为什么我知道 BCD已经比较过了呢？待匹配的子串为 ABCDABD ，当在源字符串中匹配至 ABCDABX（X != D）时， BCD 很明显不可能与字符串 A 匹配成功，但ABX 有可能与 ABC 相等，所以 ABXXXXX 有可能与 ADCDABD 匹配成功，所以我们直接将搜索位置向后移动 4 个位置
KMP 算法的想法是，设法利用这个已知信息，不要把搜索位置移回已经比较过的位置，继续把它向后移，这样就提高了效率

怎么做到把刚刚重复的步骤省略掉？可以对Str2计算出一张《部分匹配表》，这张表的产生在后面介绍。

已知空格与D不匹配时，前面六个字符”ABCDAB”是匹配的。查表可知，最后一个匹配字符B对应的”部分匹配值”为2，因此按照下面的公式算出向后移动的位数：

移动位数 = 已匹配的字符数 - 对应的部分匹配值

因为 6 - 2 等于4，所以将搜索词向后移动 4 位。

说白了，不就是字符串 ABCDAB 的后缀中包含 AB ，前缀也包含了 AB

当我们匹配到了 ABCDABX（X != D）时，其实 BCD 部分其实无须再去匹配，但因为后缀 ABX 有可能等于 ABC ，所以需要从 ABX 中的 A 开始匹配，

相同的前后缀 AB 长度为 2 ，所以搜索位置向后移动 4 位（待匹配的子串长度 - 相同的前后缀长度）

因为空格与Ｃ不匹配，搜索词还要继续往后移。

这时，已匹配的字符数为2（”AB”），对应的”部分匹配值”为0。所以，移动位数 = 2 - 0，结果为 2，于是将搜索词向后移 2 位。
来仔细想想，为啥是向后移动 2 位？
- 当我们匹配到 ABX（X != C）时，我们需要考虑搜索位置往后面移动多少个位置
- 由于字符串 AB 没有相同的前后缀，所以部分匹配值为 0 ，也就是说，如果匹配不到子串匹配到 ABX（X != C），直接从 X 的位置开始继续搜索，因为字符串 AB 中没有相同的前后缀~~~

因为空格与A不匹配，继续后移一位

逐位比较，直到发现C与D不匹配。于是，移动位数 = 6 - 2，继续将搜索词向后移动 4 位

逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。如果还要继续搜索（即找出全部匹配），移动位数 = 7 - 0，再将搜索词向后移动 7 位，这里就不再重复了

部分匹配表

有没有想过部分匹配表怎么产生的？首先我们先介绍字符串的前缀，后缀是什么？

部分匹配值”就是”前缀”和”后缀”的最长的共有元素的长度。以”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。
计算部分匹配表时，当前字符串的部分匹配表的求解依赖于上个子串的部分匹配表

”部分匹配”的实质是，有时候，字符串头部和尾部会有重复。比如，”ABCDAB”之中有两个”AB”，那么它的”部分匹配值”就是2（”AB”的长度）。搜索词移动的时候，第一个”AB”向后移动 4 位（字符串长度-部分匹配值），就可以来到第二个”AB”的位置。

KMP 算法实现

计算部分匹配表

KMP 中的关键就是求公共最长匹配前缀和后缀的长度了（多读几遍这句话，你就懂了）
next 数组的含义：next[i] 表示原字符串的子串 str.subString(0, i) 中，前缀和后缀的最长的共有元素的长度
首先，如果只包含单个字符的字符串，其部分匹配表为 { 0 } ，所以next[0] = 0;
然后索引 i 从 1 ~ dest.length() 递增，依次求取每个子串的部分匹配表，就很神奇，下一次子串的部分匹配表的求解依赖于上一次子串的部分匹配表（具体看下面）
索引 j 的含义：
索引 j 指向当前待匹配字符的索引，每当匹配到一个字符时，索引 j 便执行 +1 操作
比如匹配 ABCDA 时，i 指向最后一个 A ，即 i == 4 ，此时 j 还是 0 ，匹配到 str[i] == str[j] ，j +=1 ，为下一次匹配做准备
怎么求每个子串的部分匹配值呢？以 ABCDABD 为例
A 的部分匹配表为 { 0 } ，那么 AB、ABC、ABCD、ABCDA、ABCDAB、ABCDABD 的部分匹配表要怎么计算呢？其实每个字符串的部分匹配表都要根据上一个子串的部分匹配表来计算
比如我们需要求 ABCDAB 的部分匹配表
我们在上一步已经求出 ABCDA 的部分匹配表为 { 0, 0, 0, 0, 1 }
此时 i == 5 ，j == 1 ，我们尝试匹配 str[j] 和 str[i] ：str[j] == str[i] == ‘B’ ，匹配成功，我们在上一步部分匹配表的基础上，对最后一个部分匹配值进行 +1 操作
所以我们求得 ABCDAB 的部分匹配表为 { 0, 0, 0, 0, 1, 2 }
再来，我们现在继续求 ABCDABD 的部分匹配表
我们在上一步已经求出 ABCDAB 的部分匹配表为 { 0, 0, 0, 0, 1, 2 }
此时 i == 6 ，j == 2 ，我们尝试匹配 str[j] 和 str[i] ：str[j] == ‘C’ ， str[i] == ‘D’ ，发现 str[j] != str[i]
我们进行匹配，发现 “ABC” != “ABD” 时，j 就应该进行回退，索引 j 肯定需要往前面回溯，那么 j 怎么回溯呢？
举个例子：“ABCX” 和 “ABDX” ，其中X为任意字符，因为有字符 D 的存在，如果想要前缀与后缀匹配，只能再从头开始算起，所以j需要回退到 ABC 中的 A 字符，即 j = next[j - 1];

// 获取到一个字符串(子串) 的部分匹配表
public static int[] kmpNext(String dest) {
    // 创建一个next 数组保存部分匹配值
    int[] next = new int[dest.length()];
    next[0] = 0; // 如果字符串是长度为1 部分匹配值就是0
    for (int i = 1, j = 0; i < dest.length(); i++) {
        // 当dest.charAt(i) != dest.charAt(j) ，我们需要从next[j-1]获取新的j
        // 直到我们发现 有 dest.charAt(i) == dest.charAt(j)成立才退出
        // 这是kmp算法的核心点
        while (j > 0 && dest.charAt(i) != dest.charAt(j)) {
            j = next[j - 1];
        }

        // 当dest.charAt(i) == dest.charAt(j) 满足时，部分匹配值就是+1
        if (dest.charAt(i) == dest.charAt(j)) {
            j++;
        }
        next[i] = j;
    }
    return next;
}

执行 KMP 搜索

索引 i 从 0 ~ dest.length() 递增，依次与目标子串中的字符进行比较

next[] 为部分搜索表

如果当前字符匹配成功，则 j++ ，为匹配下一个字符做准备

如果当前字符匹配失败，则 j 往前回溯，具体做法是：从子串的部分匹配表中，获取当前需要从子串的哪个索引位置开始继续执行匹配（j = next[j - 1]），目的是为了跳过那些没有必要再比较的字符

// 写出我们的kmp搜索算法
/**
 * 
 * @param str1 源字符串
 * @param str2 子串
 * @param next 部分匹配表, 是子串对应的部分匹配表
 * @return 如果是-1就是没有匹配到，否则返回第一个匹配的位置
 */
public static int kmpSearch(String str1, String str2, int[] next) {
	// 遍历
	for (int i = 0, j = 0; i < str1.length(); i++) {

		// 需要处理 str1.charAt(i) ！= str2.charAt(j), 去调整j的大小
		// KMP算法核心点, 可以验证...
		while (j > 0 && str1.charAt(i) != str2.charAt(j)) {
			j = next[j - 1];
		}

		if (str1.charAt(i) == str2.charAt(j)) {
			j++;
		}
         
		if (j == str2.length()) { // 找到了
			return i - j + 1;
		}
	}
	return -1;
}

代码测试

首先计算待搜索子串的部分匹配表
然后从利用子串的部分匹配表，在源字符串中进行搜索

public static void main(String[] args) {

    String str1 = "BBC ABCDAB ABCDABCDABDE";
    String str2 = "ABCDABD";
    // String str2 = "BBC";

    int[] next = kmpNext("ABCDABD"); // [0, 1, 2, 0]
    System.out.println("next=" + Arrays.toString(next));

    int index = kmpSearch(str1, str2, next);
    System.out.println("index=" + index); // 15

}

程序运行结果

next=[0, 0, 0, 0, 1, 2, 0]
index=15

KMP算法的实现算是比较绕脑子的，需要多看多理解。。。。。

你走吧起风了__

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
KMP算法的实现与解析

KMP 算法介绍KMP是一个解决模式串在文本串是否出现过，如果出现过，最早出现的位置的经典算法 Knuth-Morris-Pratt 字符串查找算法，简称为 “KMP算法”，常用于在一个文本串S内查找一个模式串P的出现位置，这个算法由Donald Knuth、Vaughan Pratt、James H. Morris三人于1977年联合发表，故取这3人的姓氏命名此算法. KMP方法算法利用之前判断过信息，通过一个next数组，保存模式串中前后最长公共子序列的长度，每次回溯时，通过next数组找到，
复制链接

扫一扫