KMP算法-Java实现

时间 2019-12-11

标签 kmp 算法 java 实现栏目 Java 繁體版

原文原文链接

目的：算法

为了解决字符串模式匹配数组

历程：性能

朴素模式匹配：逐次进行比较spa

KMP算法：利用匹配失败获得的信息，来最大限度的移动模式串，以此来减小比较次数提升性能code

概念：blog

m：是目标串长度索引

n：是模式串长度字符串

j：某次匹配时，第一次出现的不一样的索引位置（有的称为：失配位）get

k：最长首尾串长度（有的称为：最长公共先后缀）string

核心思想：

S S₀ S₁...... S_i-j-1S_i-jS_i-j+1S_i-j+2...... S_i-2S_i-1S_i ...... S_n-1

|| || || || || ×

P P₀ P₁ P₂ P_j-2 P_j-1P_j

有S_i-j-1S_i-jS_i-j+1S_i-j+2...... S_i-2S_{i-1=P₀P₁ P_{2 ......}P_j-2 P_j-1}

若是 P₀P₁ P_{2 ......}P_{j-2 ≠ P₁ P_{2 ......}P_j-2P_j-1}

则能够当即判定 P₀P₁ P_{2 ......}P_{j-2 ≠ S_i-j+1S_i-j+2...... S_i-2S_{i-1，即：朴素模式匹配的下一次移动必定不匹配，则能够跳过这一次}}

若是 P₀P₁ P_{2 ......}P_{j-3 ≠ P_{2 ......}P_j-2P_j-1}

则能够当即判定 P₀P₁ P_{2 ......}P_{j-2 ≠ S_i-j+1S_i-j+2...... S_i-2S_{i-1，即：朴素模式匹配的下一次移动必定不匹配，则能够跳过这一次}}

直到第一次出现相等的状况终止：P₀P₁ P_{2 ......}P_k-1₌ P_j-k_{_......P_j-2P_j-1}

获得的k就是最长的首尾串长度，而后经过 j-k 获得了咱们须要移动的位数，这样咱们就利用了匹配失败的结果，获得了咱们能够移动的步数，提高了性能

关于k：

其实肉眼就直接能看出来，k是最长首尾串长度，好比：

11111 k=4（前缀：1111，后缀：1111）

12112 k=2（前缀：12，后缀：12）

12345 k=0（无相同前缀后缀）

例子：

S=ababababababb

P=abababb

重申一下原理：朴素模式匹配效率低的缘由是一位一位的比较，丢弃了以前失败的信息。而KMP算法从匹配失败的信息中获得能够最大移动的步数，以此来减小比较的次数，来提高性能。

这里并无说起，next数组及newnext数组，模式串的特征向量N，其实不用管它，思想理解了，只是别人起了个叫法而已。

Java代码：

    /**
     * 朴素模式匹配
     * 
     * @param source 目标串
     * @param pattern 模式串
     */
    private static void plain(String source, String pattern) {
        int res=0;
        int sourceLength=source.length();
        int patternLength=pattern.length();
        for(int i=0;i<=(sourceLength-patternLength);i++){
            res++;
            String str=source.substring(i, i+patternLength);
            if(str.equals(pattern)){
                p("朴素模式：匹配成功");
                break;
            }
        }
        p("朴素模式：一共匹配"+res+"次数");
    }

    //KMP算法实现
　　 private static void KMP(String source, String pattern) {
        int[] N=getN(pattern);
        int res=0;
        int sourceLength=source.length();
        int patternLength=pattern.length();
        for(int i=0;i<=(sourceLength-patternLength);){
            res++;
            String str=source.substring(i, i+patternLength);//要比较的字符串
            p(str);
            int count=getNext(pattern, str,N);
            p("移动"+count+"步");
            if(count==0){
                p("KMP：匹配成功");
                break;
            }
            i=i+count;
        }
        p("KMP：一共匹配"+res+"次数");
    }
    /**
     * 获得下一次要移动的次数
     * 
     * @param pattern
     * @param str
     * @param N
     * @return 0,字符串匹配；
     */
    private static int getNext(String pattern,String str,int[] N) {
        int n = pattern.length();
        char v1[] = str.toCharArray();
        char v2[] = pattern.toCharArray();
        int x = 0;
        while (n-- != 0) {
            if (v1[x] != v2[x]){
                if(x==0){
                    return 1;//若是第一个不相同，移动1步
                }
                return x-N[x-1];//x:第一次出现不一样的索引的位置，即j
            }
            x++;
        }
        return 0;
    }
    private static int[] getN(String pattern) {
        char[] pat=pattern.toCharArray();
        int j=pattern.length()-1;
        int[] N=new int[j+1];
        for(int i=j;i>=2;i--){
            N[i-1]=getK(i,pat);
        }
        for(int a:N)
            p(a);
        return N;
    }
    private static int getK(int j, char[] pat) {
        int x=j-2;
        int y=1;
        while (x>=0 && compare(pat, 0, x, y, j-1)) {
            x--;
            y++;
        }
        return x+1;
    }
    private static boolean compare(char[] pat,int b1,int e1,int b2,int e2){
        int n = e1-b1+1;
        while (n-- != 0) {
            if (pat[b1] != pat[b2]){
                return true;
            }
            b1++;
            b2++;
        }
        return false;
    }
    public static void p(Object obj) {
        System.out.println(obj);
    }

next数组：

KMP能提升性能缘由是减小了比较次数，也就是知道k

而k从只和j有关，这就意味着移动的次数只和模式串有关，和目标串无关

简单来讲，就是咱们获得模式串后就能立马知道移动的次数，这就是next数组。里面储存的就是k值。