Java数据结构与算法之KMP算法

1 字符串匹配问题、

  1）有一个字符串str1=“你好你好  你好你好 你你好你好好 ”，和一个子字符串str2="你好好",现在判断str1是否包含str2，如果存在就返回第一次出现的位置，如果没有，就返回-1.

2. 暴力匹配算法

  如果用到暴力匹配的思路，，并假设现在str1匹配到 i 位置，子串str2 匹配到 j 位置，则：

1）如果当前字符串匹配成功（即str1【i】匹配到str1【j】）,则i++，j++,继续匹配下一个字符

2）如果匹配失败（即str1【i】！=str1【j】），令i=i-(j-1),j=0，相当于每次匹配失败时，i回溯，j被置零。

3）用暴力方法解决问题的haul，就会用大量的回溯，每次只移动一个位，若是匹配不成功，移动到 下一个位置接着判断，浪费了大量的时间。

4）暴力匹配算法实现。

package KMP;

public class VioletMatch {
    public static void main(String[] args) {
        //测试暴力算法
        String str1= "你好你好  你好你好 你你好你好好";
        String str2= "你好好";
        int index = violencematch(str1, str2);
        System.out.println(index);
    }

    //暴力匹配算法
    public static int violencematch(String str1,String str2){
        char[] S1=str1.toCharArray();
        char[] S2=str2.toCharArray();
        int S1len=S1.length;
        int S2len=S2.length;
        int i=0;//i是指向S1的索引
        int j=0;//j是指向S2的索引
        while (i<S1len &&j<S2len){//先确保匹配不会越界
            if (S1[i]==S2[j]){//这个位置匹配成功
                i++;
                j++;
            }else {//没有匹配成功
                //这时就是相当于str1[i]!=str[j]，需要回溯
                i=i-(j-1);
                j=0;
            }
        }
        //判断是否匹配成功
        if (j==S2.length){
            return i-j;
        }else {
            return -1;
        }
    }
}

3.KMP 算法介绍

  1）KMP是一个解决模式串在文本串中是否出现过，如果出现过，最小出现位置的经典算法。

 2）KMP算法就是利用之前判断过的信息，通过一个next数组，保存模式串前后最长公共子序列的长度，每次回溯时，通过next数组找到，前面匹配过的位置，省去大量的时间。

4.KMP算法字符串匹配问题

有一个字符串str1="BBC ABCDAB ABCDADCBABDE"和一个子串str2="ABCDABD"

用KMP算法完成的思路分析：

1）首先str1的第一个字符串和str2的第一个字符串去比较，不符合，关键词向后移动一位。

2）重复第一步，还是不符合，再向后移动

3）一直重复，只到str1有一个字符串和str2的第一个字符符合为止。

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

 

5）遇到str1有一个字符与str2对应的字符不符合。

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

7）怎么样才能把刚刚重复的步骤省略掉呢？可以对str2计算出一张《部分匹配表》。

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

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

    6 -2 =4 ，因此搜索位置向后移动4位

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

 

10）因为空格不匹配，继续向后移动一位

 

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

5 KMP算法实现

package KMP;

import java.util.Arrays;

public class KMPAlgorithm {
    public static void main(String[] args) {
        String str1="BBC ABCDAB ABCDABCDABDE";
        String str2="ABCDABD";
        int[] next = KmpNext(str2);
        System.out.println("next="+ Arrays.toString(next));
        int index = KmpSearch(str1, str2, next);
        System.out.println("index="+index);
    }
    
    //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 int[] KmpNext(String des){
        //创建一个next数组保存部分匹配值
        int[] next=new int[des.length()];
        next[0]=0;//如果字符串长度为1，部分匹配表就是0
        for (int i = 1,j=0; i < des.length(); i++) {
            //当des.charAt(i)!=des.charAt（j），需要从next[j-1]获取新的j
            //找到我们发现  des.charAt(i)==des.charAt（j）  成立，才退出
            while (j>0 && des.charAt(i)!=des.charAt(j)){
                j=next[j-1];
            }
            //当 des.charAt(i)==des.charAt（j）  满足时，部分匹配表的值就+1
            if (des.charAt(i)==des.charAt(j)){
                j++;
            }
            next[i]=j;
        }
        return next;
    }
}