KMP算法心得

在介绍kmp算法之前，我想先简单介绍一下Brute-Force算法，这是一个回溯的字符串模式匹配算法，是一个简单暴力狂！

1-1. Brute-Force算法分析

由上图的匹配思想，主要代码如下：

public static int indexOf(String target, String pattern){
    
    int i = 0,j = 0;

    while(i < target.length() - pattern.length()){
        
        if(target.charAt(i+j) == pattern.charAt(j)){
            j++;
        }else{
            i++;
            j = 0;
        }
        if(j == pattern.length()){
            return i;
        }
    }
    return -1;
}

很明显，当匹配不成功时，目标串每次向前移动一位，模式串每次从P0开始重新匹配，双方都存在回溯现象。在上图中可以看出最差的情况： 每次匹配比较M次，比较了N - M + 1 次，比较总数是 M*(N - M + 1)，由于M << N，所以时间复杂度O(M * N) 。

下面分析下Brute-Force算法的缺点：

1-2. Brute-Force算法缺点

下面就着重讲一下KMP算法：

1. 算法描述：

   核心是找到模式串中的k( 0 <=k < j) 满足"P0...Pk-1" = "Pj-k...Pj-1" = "Ti-k...Ti-1"  (当Pj != Ti时)，则模式串从Pk开始遍历。
   

所以问题就转化为：找到串"P0...Pj-1"相同的前缀子串和后缀子串的长度k。

1-3. KMP算法描述

2. 求next数组

1-4. next公式

根据上图的模式串"abcabc"，可以得到next数组(注意在"P0...Pj-1"中寻找)

j	0	1	2	3	4	5
模式串	a	b	c	a	b	c
next[j]	-1	0	0	0	1	2

3. 计算next数组的算法

由next数组的定义可以：

• 1. next[0] = -1;
• 2.对于任意的j (0<=j
• 3. 若next[j] = k 说明在子串"P0...Pj-1"中存在相同的前缀子串和后缀子串，"P0...Pk-1" = "Pj-k...Pj-1" (0=
• 4. 对于next[j+1]而言，判断"P0...Pj"子串中，是否存在"P0...Pk" = "Pj-k...Pj-1Pj"的问题，可以分解为 ：
     • 1. 是否存在"P0...Pk-1" = "Pj-k...Pj-1"的问题；
     • 2. Pk == Pj的问题；

很符合动态规划(Dynamic Programming)的问题，把多阶段过程转化为一系列单阶段问题，利用各阶段之间的关系，逐个求解，很像分治法。
同时个人认为很像高考数列的相关问题 ---- 数学归纳法。

某个数列 An

1. An = K (常数)；
2. 假设前N项满足： An = f(n) (某个函数式)；
3. 如果第N+1项 满足 An+1 = f(n+1)，则An = f(n) 等式成立。

综上所述该动态规划的递推公式：

D(j+1) = max(D(j)) + (Pk == Pj ? 1 : 0)

4. 改进next数组

在上图1-3中 Pk = Pj , Ti != Pj => Pk != Ti 则完全没有必要回溯到Pk开始比较，直接从P0开始，所以假如next[j] = k 且 Pk = Pj 则 next[j] = next[k];

5. KMP核心代码

private static int[] getNext(String pattern){

        int j = 0,k = -1;
        int[] next = new int[pattern.length()];
        next[0] = -1;
        while(j < pattern.length() - 1){
            if(k == -1 || pattern.charAt(j) == pattern.charAt(k)){
                j++;
                k++;
                //改进next数组
                if(pattern.charAt(j) != pattern.charAt(k)){
                    next[j] = k;
                }else{
                    next[j] = next[k];
                }
            }else{
                k = next[k];
            }
        }
        return next;
    }

    public static int indexOf(String target, String pattern){
        
        int i = 0,j = 0;
        
        int[] next = getNext(pattern);
        
        while(i < target.length()){
            
            if(j == -1 || target.charAt(i) == pattern.charAt(j)){
                
                i++;
                j++;
            }else{
                j = next[j];
            }
            if(j == pattern.length()){
                
                return i - j;
            }
        }
        return -1;
    }

6. KMP算法分析

1-5. KMP算法分析

时间复杂度O(M + N) ，当M<

以上是本人对KMP算法的理解，欢迎大家指正和交流，谢谢！