用Java【KMP算法】解决字符串匹配问题

一、应用场景-字符串匹配

在字符串String basicString = "张三王五李四张三 王五李四 王 五李四 ";中查询
String searchString = "张三 王";，存在则返回首次出现的位置，否则返回-1

二、暴力算法

思路

• 如果当前字符匹配成功（即basicString[i] == searchString [j]），则i++，j++，继续匹配下一个字符
• 如果失配（即basicString[i]! = searchString [j]），令i = i - (j - 1)，j = 0。相当于每次匹配失败时，i 回溯，j 被置为0。
• 用暴力方法解决的话就会有大量的回溯，每次只移动一位，若是不匹配，移动到下一位接着判断，浪费了大量的时间。

代码实现

public class ViolenceMatch {

    public static void main(String[] args) {
        String basicString = "张三王五李四张三 王五李四 王 五李四 ";
        String searchString = "张三 王";
        int index = violenceMatch(basicString,searchString);
        System.out.println("index:"+index);
    }

    /**
     * 暴力匹配算法
     * @param basicString 基础字符串
     * @param searchString 待查找的字符串
     * @return
     */
    public static int violenceMatch(String basicString, String searchString){
        char[] basicChar = basicString.toCharArray();
        char[] searchChar = searchString.toCharArray();

        int basicLength = basicChar.length;
        int searchLength = searchChar.length;

        //i索引指向basicChar
        int basicIndex = 0;
        //j索引指向searchChar
        int searchIndex = 0;

        //保证下标不越界
        while(basicIndex < basicLength && searchIndex < searchLength){

            //进行字符匹配
            if(basicChar[basicIndex] == searchChar[searchIndex]){
                basicIndex++;
                searchIndex++;
            }else{
                //字符匹配失败
                basicIndex = basicIndex - (searchIndex - 1);
                searchIndex = 0;
            }
        }
        //判断是否匹配成功
        if(searchIndex == searchLength){
            return basicIndex - searchIndex;
        }else{
            return -1;
        }
    }
}

二、KMP算法

1. 介绍

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

2. 思路分析

举例来说，有一个字符串 Str1 = “BBC ABCDAB ABCDABCDABDE”，判断，里面是否包含另一个字符串 Str2 = “ABCDABD”？

1. 首先，用Str1的第一个字符和Str2的第一个字符去比较，不符合，关键词向后移动一位
   

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

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

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

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

6. 这时候，想到的是继续遍历Str1的下一个字符，重复第1步。(其实是很不明智的，因为此时BCD已经比较过了，没有必要再做重复的工作，一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是”ABCDAB”。KMP 算法的想法是，设法利用这个已知信息，不要把”搜索位置”移回已经比较过的位置，继续把它向后移，这样就提高了效率。)
   

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

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

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

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

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

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

13. 介绍《部分匹配表》怎么产生的
    先介绍前缀，后缀是什么
    
    “部分匹配值”就是”前缀”和”后缀”的最长的共有元素的长度。以”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。

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

到此KMP算法思想分析完毕!
参考原文详解

3. 代码实现

import java.util.Arrays;

public class KMPAlgorithm {

    public static void main(String[] args) {
        String basicString = "张三王五李四张三 王五张三 王 五李四 ";
        String searchString = "张三 王五张三";
        int index = kmpSearch(basicString,searchString);
        System.out.println("index:"+index);
    }

    /**
     * kmp搜索算法
     *
     * @param basicString  源字符串
     * @param searchString 待搜索字符串
     * @return 返回第一个匹配的位置 未找到则返回-1
     */
    public static int kmpSearch(String basicString, String searchString) {
        //获取待搜索字符串的部分匹配值
        int[] next = kmpNext(searchString);
        //输出部分匹配表
        System.out.println(Arrays.toString(next));
        for(int i = 0,j = 0;i<basicString.length();i++){
            //需要处理basicString.charAt(i) != searchString.charAt(j)
            //去调整j的大小
            while (j > 0 && basicString.charAt(i) != searchString.charAt(j)){
                j = next[j - 1];
            }
            if(basicString.charAt(i) == searchString.charAt(j)){
                j++;
            }
            if(j == searchString.length()){
                return i - j + 1;
            }
        }

        return -1;
    }

    /**
     * 计算字符串的部分匹配值
     * @param searchString
     * @return
     */
    public static int[] kmpNext(String searchString) {
        //数组保存部分匹配值
        int[] next = new int[searchString.length()];
        //若字符串的长度为1，部分匹配值为0
        next[0] = 0;
        //i => 字符，j => 部分匹配值
        for (int i = 1, j = 0; i < searchString.length(); i++) {
            //当searchString.charAt(i) != searchString.charAt(j),需要从next[j-1]获取新的j
            //知道发现searchString.charAt(i) == searchString.charAt(j) 时退出

            while(j > 0 && searchString.charAt(i) != searchString.charAt(j)){
                j = next[j - 1];
            }

            //部分匹配值+1
            if(searchString.charAt(i) == searchString.charAt(j)){
                j++;
            }
            next[i] = j;
        }
        return next;
    }
}

运行效果

KMP算法参考原文