KMP算法详解及其Java实现

KMP算法,又称作“看猫片”算法(误),是一种改进的字符串模式匹配算法,可以在O(n+m)的时间复杂度以内完成字符串的匹配操作,其核心思想在于:当一趟匹配过程中出现字符不匹配时,不需要回溯主串的指针,而是利用已经得到的“部分匹配”,将模式串尽可能多地向右“滑动”一段距离,然后继续比较。

KMP(看猫片)算法

1. 朴素的字符串模式匹配算法

求一个字符串(模式串)在另一个字符串(主串)中的位置,称为字符串模式匹配。

在朴素的字符串模式匹配算法中,我们对主串S和模式串T分别设置指针i和j,假设字符串下标从0开始,初始时i和j分别指向每个串的第0个位置。在第n趟匹配开始时,i指向主串S中的第n-1个位置,j指向模式串T的第0个位置,然后逐个向后比较。若T中的每一个字符都与S中的字符相等,则称匹配成功,否则,当遇到某个字符不相等时,i重新指向S的第n个位置,j重新指向T的第0个位置,继续进行第n+1趟匹配。

例如,我们对模式串T=“abaabcac”和主串S=“abcabaabaabcacb”进行匹配。如图1.1,此时正在进行第4趟匹配,S[3...7]与T[0...4]均相等,但当i=8,j=5时,S[8]与T[5]不相等,匹配失败。于是,置i=4,j=0,相当于将模式串向右移动一位后,重新开始下一趟匹配,如图1.2。

图1.1 当i=8,j=5时,字符不相等,匹配失败

图1.2 将模式串向右移动一位后,重新开始下一趟匹配

利用此种方法进行字符串匹配,最坏情况下时间复杂度为O(n*m),其中n和m分别为主串和模式串的长度。

2. 改进的字符串模式匹配算法——KMP算法

在上面的例子中,我们可以看到,当i=8,j=5时,S[8]与T[5]不相等,于是置i=4,j=0,相当于将模式串向右移动一位,再开始下一趟匹配。然而,通过观察我们可以发现,之后的两趟匹配,即i=4,j=0以及i=5,j=0都是不必要的。这是因为,在之前的一趟匹配过程中,我们已经部分匹配了T的子串“abaab”。此时将T向右移动一位,则相当于对T中的“abaab……”与S中的“baab……”进行匹配,显然无法匹配成功。继续右移T,则相当于对T中的“abaab……”与S中的“aab……”进行匹配,依然无法匹配成功。只有当T向右移动3位后,此时对T中的“abaab……”与S中的“ab……”进行匹配,才会有成功的可能,也就有必要向后继续进行比较。如图2.1。

图2.1 匹配失败时,将T向右移动3位后,才有继续比较的必要

因此,当i=8,j=5,T的子串“abaab”已经匹配成功,而其后一位字符却不相等时,不必回溯i指针,置i=8,j=2,继续向后比较,相当于将T向右移动3位,并从T的第3位开始向后比较。如图2.2。

图2.2 匹配失败后,直接置i=8,j=2,继续向后比较

这就是KMP算法的基本思路。对于模式串T中的前j个字符组成的子串,设置数组next[j]存放一个值,当模式串T匹配至第j个字符时与主串不相等,则i指针不变,将j指针置为next[j]的值,然后继续进行比较。在上例中,串“abaab”为模式串T的前5个字符组成的子串,令next[5]=2,当i=8,j=5时,S[8]与T[5]不相等,于是置i=8,j=next[j]=next[5]=2,然后继续进行比较。

因此,KMP算法的核心在于求出数组next,即模式串T中每一个长度为j (0<j<T.length) 的前缀所对应的next[j]的值。

next数组求解算法

在求解next数组前,我们首先需要理解next数组的含义。回到前面的例子,当T的子串“abaab”的下一个字符与主串不相等时,主串的指针i不变,j回溯至2,指向T的第3个字符,其本质是因为串“abaab”的前缀和后缀有一个长度为2的最长公共串“ab”,因此我们省略了前缀“ab”和后缀“ab”的比较过程,直接对它们的后一个字符,即T[2]和S[8]进行比较。

再看另一个例子,假设有模式串T=“abacaabadad”,其已部分匹配完T[0...7],即“abacaaba”,在匹配T[8]时遇到匹配失败,因T[0...7]的前缀和后缀有长度为3的最长公共串“aba”,因此next[8]=3,置j=next[j]=next[8]=3,i不变,然后从T[3],即T的第4个字符开始比较。如图2.3。

图2.3 匹配T[8]时失败,i不变,j回溯至3

总之,对于模式串T,next[j]代表了T的前j个字符组成的子串中,其前缀和后缀的最长公共串的长度。

求解字符串T的next数组的算法如下:

  1. next[0]=-1, next[1]=0。
  2. 在求解next[j]时,令k=next[j-1],
  3. 比较T[j-1]与T[k]的值,

    a. 若T[j-1]等于T[k],则next[j]=k+1。

    b. 若T[j-1]不等于T[k],令k=next[k],若k等于-1,则next[j]=0,否则跳至3。

下面以模式串T=“abaabcac”为例,给出求next数组的过程:

  1. next[0]=-1, next[1]=0。
  2. 当j=2时,k=next[j-1]=next[1]=0,由于T[j-1]=T[1]=‘b’,T[k]=T[0]=‘a’,T[j-1]不等于T[k],令k=next[k]=next[0]=-1,因此next[2]=0。
  3. 当j=3时,k=next[j-1]=next[2]=0,由于T[j-1]=T[2]=‘a’,T[k]=T[0]=‘a’,T[j-1]等于T[k],因此next[3]=k+1=1。
  4. 当j=4时,k=next[j-1]=next[3]=1,由于T[j-1]=T[3]=‘a’,T[k]=T[1]=‘b’,T[j-1]不等于T[k],令k=next[k]=next[1]=0。此时T[k]=T[0]=‘a’,T[j-1]等于T[k],因此next[3]=k+1=1。
  5. 当j=5时,k=next[j-1]=next[4]=1,由于T[j-1]=T[4]=‘b’,T[k]=T[1]=‘b’,T[j-1]等于T[k],因此next[5]=k+1=2。
  6. 当j=6时,k=next[j-1]=next[5]=2,由于T[j-1]=T[5]=‘c’,T[k]=T[2]=‘a’,T[j-1]不等于T[k],令k=next[k]=next[2]=0。此时T[k]=T[0]=‘a’,T[j-1]不等于T[k],再令k=next[k]=next[0]=-1,因此next[6]=0。
  7. 当j=7时,k=next[j-1]=next[6]=0,由于T[j-1]=T[6]=‘a’,T[k]=T[0]=‘a’,T[j-1]等于T[k],因此next[7]=k+1=1。

将next数组全部求出之后,只需在简单的匹配算法上稍作修改,便得到了KMP的匹配算法:当模式串T匹配至第j个字符时匹配失败,i指针不变,将j指针置为next[j]的值,若j的值为-1,则将i和j同时加1。随后继续进行逐个的比较。

下面以模式串T=“abaabcac”和主串S=“abcabaabaabcacb”进行匹配为例,给出KMP匹配算法的全过程。

之前已经求得模式串T的next数组为[-1, 0, 0, 1, 1, 2, 0, 1]。

  1. 初始时,i=0,j=0,匹配成功。

  2. i=1,j=1,匹配成功。

  3. i=2,j=2,匹配失败。

  4. i=2,j=next[2]=0,匹配失败。

  5. i=2,j=next[0]=-1,匹配失败。

  6. i=2+1=3,j=-1+1=0,匹配成功。

  7. i=4,j=1,匹配成功。

  8. i=5,j=2,匹配成功。

  9. i=6,j=3,匹配成功。

  10. i=7,j=4,匹配成功。

  11. i=8,j=5,匹配失败。

  12. i=8,j=next[5]=2,匹配成功。

  13. 继续向后比较,中间过程均匹配成功,故不再赘述,当i=13,j=7时,模式串匹配完成。

以上就是KMP匹配算法的全过程。总结一下,KMP算法的实质就是以空间换时间,在匹配之前将模式串的一些信息存储起来(next数组),在随后的匹配过程中利用这些信息减少不必要的匹配次数,以提高匹配效率。在实际的应用过程中,简单模式匹配算法的执行时间常常接近于KMP算法,仅当主串与模式串有很多“部分匹配”时,KMP算法才能显著提升性能。

3. KMP算法的Java实现

下面给出KMP算法的Java代码。整个算法分为两部分,一是next数组的求解,二是KMP匹配过程。

public class KMP {

    /**
     * 求出一个字符数组的next数组
     * @param t 字符数组
     * @return next数组
     */
    public static int[] getNextArray(char[] t) {
        int[] next = new int[t.length];
        next[0] = -1;
        next[1] = 0;
        int k;
        for (int j = 2; j < t.length; j++) {
            k=next[j-1];
            while (k!=-1) {
                if (t[j - 1] == t[k]) {
                    next[j] = k + 1;
                    break;
                }
                else {
                    k = next[k];
                }
                next[j] = 0;  //当k==-1而跳出循环时,next[j] = 0,否则next[j]会在break之前被赋值
            }
        }
        return next;
    }

    /**
     * 对主串s和模式串t进行KMP模式匹配
     * @param s 主串
     * @param t 模式串
     * @return 若匹配成功,返回t在s中的位置(第一个相同字符对应的位置),若匹配失败,返回-1
     */
    public static int kmpMatch(String s, String t){
        char[] s_arr = s.toCharArray();
        char[] t_arr = t.toCharArray();
        int[] next = getNextArray(t_arr);
        int i = 0, j = 0;
        while (i<s_arr.length && j<t_arr.length){
            if(j == -1 || s_arr[i]==t_arr[j]){
                i++;
                j++;
            }
            else
                j = next[j];
        }
        if(j == t_arr.length)
            return i-j;
        else
            return -1;
    }

    public static void main(String[] args) {
        System.out.println(kmpMatch("abcabaabaabcacb", "abaabcac"));
    }

}

参考资料及致谢

在学习KMP算法思路的过程中,我大量参考了“王道考研系列”的《数据结构联考复习指导》一书,以及CSDN博主v_JULY_v的文章:从头到尾彻底理解KMP,特此鸣谢。

同时感谢微博博主@回忆专用小马甲和实验室的大红袍CocoXu提供的大量猫片,让我在学习KMP算法的过程中拥有持续的动力。

文章中如有错误,欢迎指正!

原文地址:https://www.cnblogs.com/imzhr/p/9613963.html

时间: 2024-10-22 12:20:30

KMP算法详解及其Java实现的相关文章

[转] KMP算法详解

转载自:http://www.matrix67.com/blog/archives/115 KMP算法详解 如果机房马上要关门了,或者你急着要和MM约会,请直接跳到第六个自然段.    我们这里说的KMP不是拿来放电影的(虽然我很喜欢这个软件),而是一种算法.KMP算法是拿来处理字符串匹配的.换句话说,给你两个字符串,你需要回答,B串是否是A串的子串(A串是否包含B串).比如,字符串A="I'm matrix67",字符串B="matrix",我们就说B是A的子串.

KMP算法详解(图示+代码)

算法过程非常绕,不要企图一次就能看明白,多尝试就会明白一些.下面试图用比较直观的方法解释这个算法,对KMP算法的解释如下: 1. 首先,字符串"BBC ABCDAB ABCDABCDABDE"的第一个字符与搜索词"ABCDABD"的第一个字符,进行比较.因为B与A不匹配,所以搜索词后移一位. 2. 因为B与A不匹配,搜索词再往后移. 3. 就这样,直到字符串有一个字符,与搜索词的第一个字符相同为止. 4. 接着比较字符串和搜索词的下一个字符,还是相同. 5. 直到字

KMP算法详解(转自中学生OI写的。。ORZ!)

KMP算法详解 如果机房马上要关门了,或者你急着要和MM约会,请直接跳到第六个自然段. 我们这里说的KMP不是拿来放电影的(虽然我很喜欢这个软件),而是一种算法.KMP算法是拿来处理字符串匹配的.换句话说,给你两个字符串,你需要回答,B串是否是A串的子串(A串是否包含B串).比如,字符串A="I'm matrix67",字符串B="matrix",我们就说B是A的子串.你可以委婉地问你的MM:“假如你要向你喜欢的人表白的话,我的名字是你的告白语中的子串吗?”    

KMP算法详解(转)

KMP 算法,是由Knuth,Morris,Pratt共同提出的模式匹配算法,其对于任何模式和目标序列,都可以在线性时间内完成匹配查找,而不会发生退化, 是一个非常优秀的模式匹配算法.但是相较于其他模式匹配算法,该算法晦涩难懂,第一次接触该算法的读者往往会看得一头雾水,主要原因是KMP算法在构造跳 转表next过程中进行了多个层面的优化和抽象,使得KMP算法进行模式匹配的原理显得不那么直白.本文希望能够深入KMP算法,将该算法的各个细节彻底 讲透,扫除读者对该算法的困扰. KMP算法对于朴素匹配

Heapsort 堆排序算法详解(Java实现)

Heapsort (堆排序)是最经典的排序算法之一,在google或者百度中搜一下可以搜到很多非常详细的解析.同样好的排序算法还有quicksort(快速排序)和merge sort(归并排序),选择对这个算法进行分析主要是因为它用到了一个非常有意思的算法技巧:数据结构 - 堆.而且堆排其实是一个看起来复杂其实并不复杂的排序算法,个人认为heapsort在机器学习中也有重要作用.这里重新详解下关于Heapsort的方方面面,也是为了自己巩固一下这方面知识,有可能和其他的文章有不同的入手点,如有错

通俗易懂的KMP算法详解

角色: 甲:abbaabbaaba 乙:abbaaba 乙对甲说:「帮忙找一下我在你的哪个位置.」 甲从头开始与乙一一比较,发现第 7 个字符不匹配. 要是在往常,甲会回退到自己的第 2 个字符,乙则回退到自己的开头,然后两人开始重新比较.[1]这样的事情在字符串王国中每天都在上演:不匹配,回退,不匹配,回退,…… 但总有一些妖艳字符串要花出自己不少的时间. 上了年纪的甲想做出一些改变.于是甲把乙叫走了:「你先一边玩去,我自己研究下.」 甲给自己定了个小目标:发生不匹配,自己不回退. 甲发现,若

KMP算法详解

这几天学习kmp算法,解决字符串的匹配问题,开始的时候都是用到BF算法,(BF(Brute Force)算法是普通的模式匹配算法,BF算法的思想就是将目标串S的第一个字符与模式串T的第一个字符进行匹配,若相等,则继续比较S的第二个字符和 T的第二个字符;若不相等,则比较S的第二个字符和T的第一个字符,依次比较下去,直到得出最后的匹配结果.BF算法是一种蛮力算法.)虽然也能解决一些问题,但是这是常规思路,在内存大,数据量小,时间长的情况下,还能解决一些问题,但是如果遇到一些限制时间和内存的字符串问

(转载)KMP算法详解(写的很好)

原文地址:http://www.cnblogs.com/yjiyjige/p/3263858.html KMP算法应该是每一本<数据结构>书都会讲的,算是知名度最高的算法之一了,但很可惜,我大二那年压根就没看懂过~~~ 之后也在很多地方也都经常看到讲解KMP算法的文章,看久了好像也知道是怎么一回事,但总感觉有些地方自己还是没有完全懂明白.这两天花了点时间总结一下,有点小体会,我希望可以通过我自己的语言来把这个算法的一些细节梳理清楚,也算是考验一下自己有真正理解这个算法. 什么是KMP算法: K

模式匹配的KMP算法详解

这种由D.E.Knuth,J.H.Morris和V.R.Pratt同时发现的改进的模式匹配算法简称为KMP算法.大概学过信息学的都知道,是个比较难理解的算法,今天特把它搞个彻彻底底明明白白. 注意到这是一个改进的算法,所以有必要把原来的模式匹配算法拿出来,其实理解的关键就在这里,一般的匹配算法: int Index(String S,String T,int pos)//参考<数据结构>中的程序 { i=pos;j=1;//这里的串的第1个元素下标是1 while(i<=S.Length