KMP字符串匹配算法

1、字符串匹配是计算机的基本任务之一。

2、举例来说，有一个字符串”BBC ABCDAB ABCDABCDABDE”，我想知道，里面是否包含另一个字符串”ABCDABD”？许多算法可以完成这个任务，Knuth-Morris-Pratt 算法（简称 KMP）是最常用的之一。

3、KMP算法是一种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt同时发现，因此人们称它为克努特——莫里斯——普拉特操作（简称KMP算法）。

4、KMP算法的关键是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。

5、具体实现就是实现一个next()函数，函数本身包含了模式串的局部匹配信息。

下面来举一个比较流行易懂的例子;
1.

首先，字符串”BBC ABCDAB ABCDABCDABDE”的第一个字符与搜索词”ABCDABD”的第一个字符，进行比较。因为B与A不匹配，所以搜索词后移一位。

2.

因为B与A不匹配，搜索词再往后移。

3.

就这样，直到字符串有一个字符，与搜索词的第一个字符相同为止。

4.

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

5.

直到字符串有一个字符，与搜索词对应的字符不相同为止。

6.

这时，最自然的反应是，将搜索词整个后移一位，再从头逐个比较。这样做虽然可行，但是效率很差，因为你要把”搜索位置”移到已经比较过的位置，重比一遍。

7.

一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是”ABCDAB”。KMP算法的想法是，设法利用这个已知信息，不要把”搜索位置”移回已经比较过的位置，继续把它向后移，这样就提高了效率。

8.

怎么做到这一点呢？可以针对搜索词，算出一张《部分匹配表》（Partial Match Table）。这张表是如何产生的，后面再介绍，这里只要会用就可以了。

9.

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

10.

因为空格与Ｃ不匹配，搜索词还要继续往后移。这时，已匹配的字符数为2（”AB”），对应的”部分匹配值”为0。所以，移动位数 = 2 - 0，结果为 2，于是将搜索词向后移2位。

11.

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

12.

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

13.

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

14.

下面介绍《部分匹配表》是如何产生的。
首先，要了解两个概念：”前缀”和”后缀”。 “前缀”指除了最后一个字符以外，一个字符串的全部头部组合；”后缀”指除了第一个字符以外，一个字符串的全部尾部组合。

15.

“部分匹配值”就是”前缀”和”后缀”的最长的共有元素的长度。以”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。

16.

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

【java代码实现】

package mathstudy;

public class KMP {
    private static int[] nextArray = null;
    private static String originString = null;
    private static String moduleString = null;


    public static void main(String[] args) {
        originString = "BBCABCDABABCDABCDABDE";
        moduleString = "ABCDABD";

        nextArray = matchStr();

        if (nextArray != null) {
            System.out.println("部分匹配表的值：");
            for (int index : nextArray) {
                System.out.print(index + " ");
            }
        }

        int index =getIndexOfStr();
        System.out.println();
        System.out.println("匹配的下标：");
        System.out.println(index+"");
    }


    /** * 计算每个元素对应的"部分匹配值" */
    private static int[] matchStr() {
        if (moduleString == null || moduleString.length() == 0) {
            return null;
        }

        int[] matchArray = new int[moduleString.length()];

        for (int i = 0; i < moduleString.length(); i++) {
                boolean hasEqual = false;
                for (int j = 0; j <= i - 1; j++) {
                    String prefixStr = moduleString.substring(0, j + 1);
                    String suffixStr = moduleString.substring(i - j, i + 1);
                    if (prefixStr.endsWith(suffixStr)) {
                        hasEqual = true;
                        matchArray[i] = prefixStr.length();
                        break;
                    } 
                }
                if (hasEqual == false) {
                    matchArray[i] = 0;
                }
            }

        return matchArray;
    } 

     /*KMP匹配字符串 * @return 若匹配成功，返回下标，否则返回-1 * */
    public static int getIndexOfStr() {

        if (moduleString == null || moduleString.length() <= 0) {
            return -1;
        }
        if (originString == null || originString.length() <= 0) {
            return -1;
        }
        if (originString.length() < moduleString.length()) {
            return -1;
        }
        int indexOfStr = -1;
        int totalLength = originString.length();
        boolean flag_end = false;

        int origin_index = 0;
        int module_index = 0;
        while (flag_end == false) {

            char char_origin = originString.charAt(origin_index);
            char char_module = moduleString.charAt(module_index);

            if (char_origin == char_module) {
                if (module_index == moduleString.length() - 1) {
                    indexOfStr = origin_index - module_index;
                    break;
                } else {

                    origin_index++;
                    module_index++;
                }

            } else {
                if (module_index == 0) {
                    origin_index++;
                    module_index = 0;
                    if (origin_index >= totalLength) {
                        break;
                    }
                } else {
                    if (module_index <= 0) {
                        module_index++;
                        origin_index++;
                    } else {
                        module_index = nextArray[module_index - 1];
                    }
                }
                continue;

            }
            if (origin_index >= totalLength) {
                break;
            }

        }
        return indexOfStr;
    }

}

输出结果：

部分匹配表的值：
0   0   0   0   1   2   0   
匹配的下标：
13