字符串匹配KMP算法原理及java实现

KMP算法求解什么类型问题

字符串匹配。给你两个字符串，寻找其中一个字符串是否包含另一个字符串，如果包含，返回包含的起始位置。

一般匹配字符串时，我们从目标字符串str（假设长度为n）的第一个下标选取和ptr长度（长度为m）一样的子字符串进行比较，如果一样，就返回开始处的下标值，不一样，选取str下一个下标，同样选取长度为n的字符串进行比较，直到str的末尾（实际比较时，下标移动到n-m）。这样的时间复杂度是O(n*m)。

kmp算法的时间复杂度就是O（m+n）

• 假设现在文本串S匹配到 i 位置，模式串P匹配到 j 位置
• 如果j = -1，或者当前字符匹配成功（即S[i] == P[j]），都令i++，j++，继续匹配下一个字符；
• 如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j =
  next[j]。此举意味着失配时，模式串P相对于文本串S向右移动了j - next [j] 位。
• 换言之，当匹配失败时，模式串向右移动的位数为：失配字符所在位置 - 失配字符对应的next 值（next
  数组的求解会在下文的3.3.3节中详细阐述），即移动的实际位数为：j - next[j]，且此值大于等于1。

kmp算法的核心就是计算next数组。next数组的计算方法：
next数组的计算主要跟模式串有关，与文本串并没有关系，为模式串前后公共最长子序列。

public class KMP {
    public static int kmp(String str, String dest,int[] next){//str文本串  dest 模式串
        for(int i = 0, j = 0; i < str.length(); i++){
            while(j > 0 && str.charAt(i) != dest.charAt(j)){
                j = next[j - 1];
            }
            if(str.charAt(i) == dest.charAt(j)){
                j++;
            }
            if(j == dest.length()){
                return i-j+1;
            }
        }
        return 0;
    }
    public static int[] kmpnext(String dest){
        int[] next = new int[dest.length()];
        next[0] = 0;
        for(int i = 1,j = 0; i < dest.length(); i++){
            while(j > 0 && dest.charAt(j) != dest.charAt(i)){
                j = next[j - 1];
            }
            if(dest.charAt(i) == dest.charAt(j)){
                j++;
            }
            next[i] = j;
        }
        return next;
    }
    public static void main(String[] args){
        String a = "ababa";
        String b = "ssdfgasdbababa";
        int[] next = kmpnext(a);
        int res = kmp(b, a,next);
        System.out.println(res);
        for(int i = 0; i < next.length; i++){
            System.out.println(next[i]);            
        }
        System.out.println(next.length);
    }
}

KMP研究参考：
http://blog.csdn.net/v_july_v/article/details/7041827
https://blog.csdn.net/hyjoker/article/details/51190726
https://blog.csdn.net/seu_calvin/article/details/62232825
https://www.cnblogs.com/ECJTUACM-873284962/p/6751457.html

字符串匹配—暴力匹配算法

假设现在我们面临这样一个问题：有一个文本串S，和一个模式串P，现在要查找P在S中的位置，怎么查找呢？

首先，先理清楚了暴力匹配算法的流程及内在的逻辑：

如果用暴力匹配的思路，并假设现在文本串S匹配到 i 位置，模式串P匹配到 j 位置，则有：

如果当前字符匹配成功（即S[i] == P[j]），则i++，j++，继续匹配下一个字符；
如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0。相当于每次匹配失败时，i 回溯，j 被置为0。
举个例子，如果给定文本串S：“BBC ABCDAB ABCDABCDABDE”，和模式串P：“ABCDABD”，现在要拿模式串P去跟文本串S匹配，整个过程如下所示：
S[0]为B，P[0]为A，不匹配，执行第②条指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，然后该判断S[1]跟P[0]是否匹配，相当于模式串要往右移动一位（i=1，j=0）

/**
     * 暴力匹配字符串算法
     * 思路：
     * ①如果当前字符匹配成功（即S[i] == P[j]），则i++，j++
     * ②如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0 .相当于每次匹配失败时，i 回溯，j 被置为0。
     * 时间复杂度为O(mn)（m、n分别为文本串和模式串的长度）。无需扩展存储空间。
     * @param text 文本串
     * @param pattern 模式串
     * @return  pattern返回在text中的位置
     */
    public static int bruteForceSearchPatternInText(String text,String pattern){
        int sLen = text.length();
        int pLen = pattern.length();

        char[] s = text.toCharArray();
        char[] p = pattern.toCharArray();

        while(sLen < pLen){
            return -1;
        }

        int i = 0 ;
        int j = 0 ;
        while(i < sLen && j < pLen){
            if(s[i] == p[j]){
                //如果当前字符匹配成功（即S[i] == P[j]），则i++，j++     
                i = i+1;
                j = j+1;
            }else{
                //如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0 
                i = i - (j-1);
                j = 0;
            }
        }
        //匹配成功，返回模式串p在文本串s中的位置，否则返回-1  
        if(j == pLen){
            return i-j;
        }else{
            return -1;
        }

    }

上面的算法分析过程中，第6步后，我们会发现S[5]肯定跟P[0]失配。为什么呢？因为在之前第4步匹配中，我们已经得知S[5] = P[1] = B，而P[0] = A，即P[1] != P[0]，故S[5]必定不等于P[0]，所以回溯过去必然会导致失配。那有没有一种算法，让i 不往回退，只需要移动j 即可呢？答案是肯定的。这种算法就是KMP算法，它利用之前已经部分匹配这个有效信息，保持i 不回溯，通过修改j 的位置，让模式串尽量地移动到有效的位置。