精华内容
下载资源
问答
  • KMP算法java实现

    2017-06-12 17:01:21
    欢迎讨论
  • 主要介绍了如何通过Java代码实现KMP算法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • kMP算法JavakMP算法JavakMP算法JavakMP算法JavakMP算法JavakMP算法JavakMP算法JavakMP算法JavakMP算法JavakMP算法JavakMP算法JavakMP算法JavakMP算法JavakMP算法JavakMP算法JavakMP算法JavakMP算法JavakMP算法Java...
  • Kmp算法Java实现源码

    2012-11-29 12:40:36
    KMP算法是通过分析子串,预先计算每个位置发生不匹配的时候,所需GOTO的下一个比较位置,整理出来一个next数组,然后在上面的算法中使用。
  • JAVA实现KMP算法

    2017-04-30 12:47:38
    JAVA实现KMP算法,使用java语言实现的kmp算法
  • KMP算法Java实现

    2014-09-19 13:23:32
    KMP算法实现,用Java语言实现的KMP字符串匹配算法
  • KMP算法 java

    2011-10-16 14:30:50
    java写的KMP算法,这是个描述KMP算法java类,里面包含了主函数的实例
  • KMP算法KMP算法是一种改进的字符串匹配算法,由D.E.Knuth,J.H.Morris和V.R.Pratt提出的,因此人们称它为克努特—莫里斯—普拉特操作(简称KMP算法)。KMP算法的核心是利用匹配失败后的信息,尽量减少模式串与...

    KMP算法

    ​ KMP算法是一种改进的字符串匹配算法,由D.E.Knuth,J.H.Morris和V.R.Pratt提出的,因此人们称它为克努特莫里斯普拉特操作(简称KMP算法)。KMP算法的核心是利用匹配失败后的信息,尽量减少模式串与主串的匹配次数以达到快速匹配的目的。

    暴力匹配

    ​ 现在需要确定一个字符串needle是否在另一个字符串haystack里面,可以使用最简单得暴力匹配来解决问题,我们先来看看暴力匹配:

    //abacaaacabacabaabb
    //abacab
    class Violent{
        public int ViolentMath(String haystack,String needle){
            int i = 0;
            int j = 0;
            while(i < haystack.length() && j < needle.length()){
                //如果相等,i和j同时向后移动
                if(haystack.charAt(i) == needle.charAt(j)){
                    i++;
                    j++;
                }else{
                    //改变i指针,讲j赋值为0
                    i = i - j + 1;
                    j = 0;
                }
            }
            if(j == needle.length()){
                return i - j;
            }
            return -1;
        }
    }
    

    ​ 上述算法中,我们可以带入例子进行简单的演算:haystack为abacaaacabacabaabb,needle为abacab。
    在这里插入图片描述

    1. 进入循环,haystack[0]==needle[0],然后i和j同时向后移动,i = j = 1;
    2. 然后连续4个都是相等的,所以i = j = 4;[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ASp7bEVt-1581158403161)(C:\Users\七夏\AppData\Roaming\Typora\typora-user-images\image-20200208170037244.png)]
    3. 当i和j在向后移动一位时,haystack[5] != needle[5],接着进入else中,i=5-5+1=1,所以下次循环时,i从1开始,j从头开始即0;在这里插入图片描述
    4. 接着,就如上述过程继续进行匹配,直到j或i超出needle.length()或haystack.length()的范围退出while循环;
    5. 最后如果j与needle.length()相等的话,说明j先不满足条件退出的循环,则needle字符串在haystack中,最终返回needle在haystack中出现的第一个位置即可。

    ​ 上述的算法很好理解,但是时间复杂度为O(n^2),所以,我们要进行算法的优化——KMP算法。

    KMP算法

    ​ 在KMP算法中最终要的就是其中的next[]数组的确定,这个数组存储的是needle字符串的最长前缀,例如needle字符串abacab。

    在这里插入图片描述

    ​ 上图中就是needle字符串的最长相同前缀表,正如我们看到的,该字符串开头的a字符前面没有和它相同的字符,因此该位置为0,b也是如此,接下来的a因为字符串的开始就是a所以该位置为1,表示前面有相同的1个字符,然后以此类推得到此表。

    ​ 在生成next数组时,我们将next[0]设置为-1,然后将其余的位置的值按照上图向后推一个位置,如下图所示:

    在这里插入图片描述

    ​ 为什么要这样呢?我们看代码

    public int[] next(String needle){
            int[] next = new int[needle.length()];
            int i = 0;
            int j = -1;
            next[0] = -1;
            while(i < needle.length()-1){
                if(j == -1 || needle.charAt(i) == needle.charAt(j)){
                    next[++i] = ++j;
                }else{
                    j = next[j];
                }
            }
            return next;
        }
    

    ​ 这个方法中,将next[0]赋值为-1,后面的值都向后移动一位其实和最长相同前缀的值在算法中的作用一致,这样的话会跟好的编写算法。

    1. 进入循环,当j为-1或者字符匹配相等的话就直接进入if语句,开始时很显然j为-1,因此,next[1] = 0;
    2. j不为-1而且needle.charAt(1)和needle.charAt(0)不相等,所以进入else语句,j=next[0]=-1;
    3. j为-1,进入if语句,所以next[2] = 0,j=0;
    4. j不为-1但是needle.charAt(2)和needle.charAt(0)相等,所以next[3]=1,j=1;
    5. j不为-1而且needle.charAt(3)和needle.charAt(1)不相等,因此j=next[1]=0;
    6. j不为-1而且needle.charAt(3)和needle.charAt(0)不相等,因此j=next[0]=-1;
    7. j为-1,进入if语句,所以next[4]=0,j=0;
    8. j不为-1但是needle.charAt(4)和needle.charAt(0),因此next[5]=1,j=1;
    9. 此时,i=5因此5不小于needle.length()-1,所以退出while循环,将next数组地址返回。

    ​ 上述生成next数组里面的值和之前的最长相同前缀的值作用是一样的,接下来我们看KMP算法的主体部分。

    	//abacaaacabacabaabb
        //abacab
        public int kmp(String haystack,String needle){
            int i = 0;
            int j = 0;
            int[] next = next(needle);
            while(i < haystack.length() && j < needle.length()){
                if(j == -1 || haystack.charAt(i) == needle.charAt(j)){
                    i++;
                    j++;
                }else{
                    j = next[j];
                }
            }
            if(j == needle.length()){
                return i - j;
            }
            return -1;
        }
    

    ​ 我们将next数组带入循环,只要当j==-1或者haystack.charAt(i) == needle.charAt(j)时,我们和暴力算法一样,将i和j直接同时向后移动一位;否则,就利用next数组改变j的值,使该算法根据next数组中的最长相同前缀的值“跳着匹配”从而避免时间复杂度的上升。

    1. 进入循环后,j不为-1,但是haystack.charAt(0) == needle.charAt(0),所以,i=j=1;
    2. j不为-1,但是haystack.charAt(1) == needle.charAt(1),所以,i=j=2;
    3. 以此类推,进行到i=j=5时,haystack.charAt(5) != needle.charAt(5),进入else语句,因此j=next[5]=1;在这里插入图片描述
    4. j不为-1,而且haystack.charAt(5) != needle.charAt(1),进入else语句,因此j=next[1]=0;在这里插入图片描述
    5. j不为-1,但是haystack.charAt(5) == needle.charAt(0),进入if语句,所以,i=6,j=1;在这里插入图片描述
    6. j不为-1,而且haystack.charAt(6) != needle.charAt(1),进入else语句,因此j=next[1]=0;在这里插入图片描述
    7. j不为-1,但是haystack.charAt(6) == needle.charAt(0),进入if语句,所以,i=7,j=1;在这里插入图片描述
    8. j不为-1,而且haystack.charAt(7) != needle.charAt(1),进入else语句,因此,j=next[1]=0;
    9. j不为-1,而且haystack.charAt(7) != needle.charAt(0),进入else语句,因此,j=next[0]=-1;
    10. j为-1,进入if语句,所以,i=8,j=0;
    11. j不为-1,但是haystack.charAt(8) == needle.charAt(0),进入if语句,所以,i=9.j=1;在这里插入图片描述
    12. 这样看来,就会进入正常的if语句直到j不满足while循环的条件而退出;
    13. 退出while循环后,j的值肯定等于6也就时needle字符串的长度,因此我们直接返回i-j也就是14-6=8,最终,8就是needle在haystack字符串中出现的第一个位置。
    展开全文
  • KMP算法java实现so easy

    2020-09-14 23:36:05
    KMP算法java实现 注意几点,kmp如此简单 1.关于k的意义必须明确他是代表前缀和后缀所以子集的交集。(拿abc来说前缀有a,ab,后缀有bc,c,此时k为0) 2.只有了解前缀和后缀的定义,才能很轻松的明白不满足是回退的操作k...

    KMP算法java实现

    注意几点,kmp如此简单
    1.关于k的意义必须明确他是代表前缀和后缀所以子集的交集。(拿abc来说前缀有a,ab,后缀有bc,c,此时k为0)
    2.只有了解前缀和后缀的定义,才能很轻松的明白不满足是回退的操作k=next[k-1];

    public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            String tarStr = scanner.nextLine();
            String partten = scanner.nextLine();
            // 手撕kmp
            int[] next = getNext(partten);
            System.out.println(Arrays.toString(next));
            for (int i=0,j=0;i<tarStr.length();i++){
                while(j>0 && tarStr.charAt(i)!=partten.charAt(j)){
                    j = next[j-1];
                }
                if(tarStr.charAt(i)==partten.charAt(j)){
                    j++;
                }
                if(j==partten.length()){
                    System.out.println(i-j+1);
                    j = 0;
                }
            }
        }
    
    private static int[] getNext(String partten){
            int[] nextArr = new int[partten.length()];
            nextArr[0] = 0;
            for (int i=1,k=0;i<partten.length();i++){
                if(partten.charAt(i)==partten.charAt(k)){
                    k++;
                }
                while(k>0 && partten.charAt(k)!=partten.charAt(i)){
                    k = nextArr[k-1];
                }
                nextArr[i] = k;
            }
            return nextArr;
        }
    

    大喊一声江哥牛逼

    展开全文
  • KMP算法Java语言实现

    2020-06-06 14:39:37
    import java.util.Scanner; public class MainKMP { public static void main(String[] args) { Scanner sc = new Scanner(System.in); String str1 = sc.nextLine(); String str2 = sc.nextLine(); char[] ...
    import java.util.Scanner;
    
    public class MainKMP {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            String str1 = sc.nextLine();
            String str2 = sc.nextLine();
            char[] strs = str1.toCharArray();
            char[] strm = str2.toCharArray();
            System.out.println(GetIndex(strs, strm));
        }
    
        public static int GetIndex(char[] strs, char[] strm) {
            if (strm.length <= 0 || strs.length <= 0 || strm.length > strs.length)
                return -1;
            int[] nextArr = GetNextArray(strm);
            int mi = 0;
            int si = 0;
            while (mi < strm.length && si < strs.length) {
                if (strm[mi] == strs[si]) {
                    mi++;
                    si++;
                }else if (mi > 0) {
                    mi = nextArr[mi];
                } else {
                    si++;
                }
            }
            return mi == strm.length ? si - mi : -1;
        }
    
        public static int[] GetNextArray(char[] str2) {
            if (str2.length < 2) {
                return new int[]{ -1 };
            }
            int[] nextArr = new int[str2.length];
            nextArr[0] = -1;//第一个位置前面没有元素,将其定义为-1
            nextArr[1] = 0;//第二个位置前面只有一个元素,匹配子串的定义是前缀子串不包括最后一个元素,后缀子串不包括第一个元素,因此前面匹配子串的长度为0
            int pos = 2;//下一步进行比较的位置为第三个位置;
            int cn = 0;//cn为上一个字符匹配前缀子串的下一个元素位置;
            while (pos < str2.length) {
                if (str2[pos] == str2[cn]) {
                    nextArr[pos++] = ++cn;
                } else if (cn > 0) {
                    cn = nextArr[cn];
                } else {
                    nextArr[pos++] = 0;
                }
            }
            return nextArr;
        }
    }
    
    
    展开全文
  • java实现KMP 算法

    千次阅读 多人点赞 2019-10-16 17:22:11
    一、应用场景-字符串匹配问题 字符串匹配问题: 有一个字符串 str1= ““硅硅谷 尚硅谷你尚硅 尚硅谷你...二、暴力匹配算法 如果用暴力匹配的思路,并假设现在 str1 匹配到 i 位置,子串 str2 匹配到 j 位置,则有: ...

    一、应用场景-字符串匹配问题

    字符串匹配问题:

    1. 有一个字符串 str1= ““硅硅谷 尚硅谷你尚硅 尚硅谷你尚硅谷你尚硅你好””,和一个子串 str2=“尚硅谷你尚硅你”
    2. 现在要判断 str1 是否含有 str2, 如果存在,就返回第一次出现的位置, 如果没有,则返回-1

    二、暴力匹配算法

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

    1. 如果当前字符匹配成功(即str1[i]==str2[j]),则i++,j++,继续匹配下一个字符
    2. 如果失配(即str1[i]!=str2[j]),令i=i-(j-1),j=0。相当于每次匹配失败时,i回溯,j被置为0。
    3. 用暴力方法解决的话就会有大量的回溯,每次只移动一位,若是不匹配,移动到下一位接着判断,浪费了大量
      的时间。(不可行!)
    4. 暴力匹配算法实现.
    5. 代码
    package kmp;
    
    /**
     * @program: text
     * @description: 暴力匹配算法
     * @author: min
     * @create: 2019-10-16 17:26
     **/
    public class ViolenceMatch {
        public static void main(String[] args) {
            String str1 = "硅硅谷 尚硅谷你尚硅 尚硅谷你尚硅谷你尚硅你好";
            String str2 = "尚硅谷你尚硅你~";
            int index = violenceMatch(str1, str2);
            System.out.println("index=" + index);
        }
    
        /**
         * 暴力匹配算法实现
         *
         * @param str1
         * @param str2
         * @return
         */
        private 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]) {//匹配 ok
                    i++;
                    j++;
                } else { //没有匹配成功
                    //如果失配(即 str1[i]! = str2[j]),令 i = i - (j - 1),j = 0。
                    i = i - (j - 1);
                    j = 0;
                }
            }
    
            //判断是否匹配成功
            if (j == s2Len) {
                return i - j;
            } else {
                return -1;
            }
        }
    }
    
    

    三、KMP 算法介绍

    1. KMP 是一个解决模式串在文本串是否出现过,如果出现过,最早出现的位置的经典算法
    2. Knuth-Morris-Pratt 字符串查找算法,简称为 “KMP 算法”,常用于在一个文本串 S 内查找一个模式串 P 的 出现位置,这个算法由 Donald Knuth、Vaughan Pratt、James H. Morris 三人于 1977 年联合发表,故取这 3 人的姓氏命名此算法.
    3. KMP 方法算法就利用之前判断过信息,通过一个 next 数组,保存模式串中前后最长公共子序列的长度,每次回溯时,通过 next 数组找到,前面匹配过的位置,省去了大量的计算时间

    四、KMP 算法最佳应用-字符串匹配问题

    字符串匹配问题:

    1. 有一个字符串str1=“BBCABCDABABCDABCDABDE”,和一个子串str2=“ABCDABD”
    2. 现在要判断 str1 是否含有 str2, 如果存在,就返回第一次出现的位置, 如果没有,则返回-1
    3. 要求:使用KMP算法完成判断,不能使用简单的暴力匹配算法.

    思路分析图解

    举例来说,有一个字符串 Str1 = “BBC ABCDAB ABCDABCDABDE”,判断,里面是否包含另一个字符串 Str2 = “ABCDABD”?
    1.首先,用 Str1 的第一个字符和 Str2 的第一个字符去比较,不符合,关键词向后移动一位
    在这里插入图片描述
    2. 重复第一步,还是不符合,再后移
    在这里插入图片描述
    3. 一直重复,直到Str1有一个字符与Str2的第一个字符符合为止
    在这里插入图片描述
    4. 接着比较字符串和搜索词的下一个字符,还是符合。
    在这里插入图片描述
    5.遇到 Str1 有一个字符与 Str2 对应的字符不符合。
    在这里插入图片描述
    6.这时候,想到的是继续遍历 Str1 的下一个字符,重复第 1 步。(其实是很不明智的,因为此时 BCD 已经比较过了, 没有必要再做重复的工作,一个基本事实是,当空格与 D 不匹配时,你其实知道前面六个字符是”ABCDAB”。 KMP 算法的想法是,设法利用这个已知信息,不要把”搜索位置”移回已经比较过的位置,继续把它向后移,这 样就提高了效率。)
    在这里插入图片描述
    7.怎么做到把刚刚重复的步骤省略掉?可以对 Str2 计算出一张《部分匹配表》,这张表的产生在后面介绍
    在这里插入图片描述
    8.已知空格与 D 不匹配时,前面六个字符”ABCDAB”是匹配的。查表可知,最后一个匹配字符 B 对应的”部分 匹配值”为 2,因此按照下面的公式算出向后移动的位数:
    移动位数 = 已匹配的字符数 - 对应的部分匹配值因为 6 - 2 等于 4,所以将搜索词向后移动 4 位。

    9.因为空格与C不匹配,搜索词还要继续往后移。这时,已匹配的字符数为 2(”AB”),对应的”部分匹配值” 为 0。所以,移动位数 = 2 - 0,结果为 2,于是将搜索词向后移 2 位。
    在这里插入图片描述
    10.因为空格与 A 不匹配,继续后移一位。
    在这里插入图片描述
    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。

    14.”部分匹配”的实质是,有时候,字符串头部和尾部会有重复。比如,”ABCDAB”之中有两个”AB”,那么 它的”部分匹配值”就是 2(”AB”的长度)。搜索词移动的时候,第一个”AB”向后移动 4 位(字符串长度- 部分匹配值),就可以来到第二个”AB”的位置。
    在这里插入图片描述
    到此 KMP 算法思想分析完毕!

    五、代码实现

    package kmp;
    
    import java.util.Arrays;
    
    /**
     * @program: text
     * @description: kmp算法
     * @author: min
     * @create: 2019-10-17 16:08
     **/
    public class KMPAlgorithm {
        public static void main(String[] args) {
            String str1 = "BBC ABCDAB ABCDABCDABDE";
            String str2 = "ABCDABD";
            //String str2 = "BBC";
            int[] next = kmpNext("ABCDABD"); //[0, 1, 2, 0]
            System.out.println("next=" + Arrays.toString(next));
            int index = kmpSearch(str1, str2, next);
            System.out.println("index=" + index); // 15 了
    
        }
    
        /**
         * @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()) {//找到了 // j = 3 i
                    return i - j + 1;
                }
            }
            return -1;
        }
    
        //获取到一个字符串(子串) 的部分匹配值表
        public static int[] kmpNext(String dest) {
            //创建一个 next 数组保存部分匹配值
            int[] next = new int[dest.length()];
            next[0] = 0; //如果字符串是长度为 1 部分匹配值就是 0
            for (int i = 1, j = 0; i < dest.length(); i++) {
                //当 dest.charAt(i) != dest.charAt(j) ,我们需要从 next[j-1]获取新的 j
                //直到我们发现 有 dest.charAt(i) == dest.charAt(j)成立才退出
                //这时 kmp 算法的核心点
                while (j > 0 && dest.charAt(i) != dest.charAt(j)) {
                    j = next[j - 1];
                }
    
                //当 dest.charAt(i) == dest.charAt(j) 满足时,部分匹配值就是+1
                if(dest.charAt(i) == dest.charAt(j)) {
                    j++;
                }
                next[i] = j;
            }
            return next;
        }
    }
    
    

    转载至:尚硅谷_韩顺平_图解Java数据结构和算法.pdf

    展开全文
  • KMP算法Java代码实现

    2019-02-28 16:55:00
     KMP算法是一种改进的字符串匹配算法,由D.E.Knuth,J.H.Morris和V.R.Pratt同时发现,因此人们称它为克努特——莫里斯——普拉特操作(简称KMP算法)。KMP算法的关键是利用匹配失败后的信息,尽量减少模式串与主串...
  • KMP算法是一种改进的字符串匹配算法,由D.E.Knuth,J.H.Morris和V.R.Pratt提出,所以被称为看毛片算法(我可不知道毛片是什么东西)。 其核心思想就是利用模式串的局部对称,在每一次匹配失败后,达到一种玄幻的跳跃...
  • KMP算法JAVA实现

    千次阅读 2016-09-28 21:28:10
    KMP算法为的是解决两个字符串匹配问题的算法,检查一个字符串是否为另一个...首先要弄清什么是KMP算法:请查看 阮一峰老师写的介绍KMP的博客,这是一篇真的容易懂的KMP算法介绍点击此处跳转到文章出处2.JAVA实现计算出
  • kmp算法java实现

    2019-04-14 22:50:51
    KMP算法要解决的问题就是在字符串(也叫主串)中的模式(pattern)定位问题。说简单点就是我们平时常说的关键字搜索。模式串就是关键字(接下来称它为P),如果它在一个主串(接下来称为T)中出现,就返回它的具体...
  • kmp
  • KMP算法 Java实现

    2021-01-30 15:40:47
    class KMP { public int kmp(String text, String pattern) { int[] next = getNext(pattern); char[] t = text.toCharArray(), p = pattern.toCharArray(); int tlen = text.length(), plen = pattern....
  • kmp算法 java实现

    2017-06-16 10:30:08
    使用KMP算法只需先进行一个O(m)的预处理(生成next数组),就能将搜索的时间复杂度降低至O(n+m)。下面讲一讲KMP算法的实现原理。 对于ABCDEABD...和ABCDEABC,当匹配至最后一位是发现不匹配,之前的ABCDEAB都是...
  • KMP算法java实现)

    2019-02-19 16:09:03
    next数组的求解: 求next数组的方法与这位大佬一样,感...直接上根据这个方法我写的kmp  package suanfaTest; import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class ...
  • 什么是 KMP 算法? 该算法因为其优秀的简称获得江湖称号 "看毛片算法",简单来说 KMP 算法就是解决字符串匹配的一种算法,它通常用来解决主字符串和模式字符串的匹配问题,如存在字符串 A = "ababcde" 和 字符串 B ...
  • kmp算法Java实现代码

    2019-02-25 19:35:24
    话不多说直接上代码。过几天写思想和原理,绝对是最通俗... public static int kmp(String str,String tar){ //获得next数组 int[] next=getNext(tar); for (int i = 0,j=0; i &lt; str.length(); i++) { ...
  • kmp算法java代码

    2016-09-01 16:26:12
    import java.util.*; /** * Created by jiangli on 2016/9/1. */ public class kmpMatch { //预处理:得到模式串p的前缀数组 public static int[] computePre(char[] p){ int m = p.length; int[] x =

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,188
精华内容 4,075
关键字:

kmp算法java

java 订阅