【数据结构&&等差数列】KMP简介和算法的实现(c++ && java)

KMP算法假定了解案件的原则,其实很easy。

KMP算法简述

关于根据自己的理解在这里。

KMP该算法由三个发明人的名称(Knuth、Morris、Pratt)的首字母组成,又称字符串查找算法。

个人认为能够理解为最小回溯算法,即匹配失效的时候,尽量少回溯。从而缩短时间复杂度。

KMP算法有两个关键的地方。1)求解next数组。2)利用next数组进行最小回溯。

1)求解next数组

next数组的取值仅仅与模式串有关。next数组用于失配时回溯使用。

在简单版本号的KMP算法中,每一个位置 j 的 next 值表示的是模式串的最长前缀的最后一个字符的位置(如果为 k ),当中最长前缀(长度为 k+1 )须要与模式串截至当前位置长度亦为 k+1 的后缀匹配。且 k 最大为 j-1 ,否则相当于没有回溯。

当k=-1的时候。表示找不到这种最长前缀。

用公式表示为

当k=-1的时候。表示空串。p表示模式串。

以下举一个计算next数组的样例,如果模式串是 “ abaabcaba ” 。

j 0 1 2 3 4 5 6 7 8
p a b a a b c a b a
next[j] -1 -1 0 0 1 -1 0 1 2

以 j = 8 为例,最长前缀为aba,最后一个字符位置为2,故 next[8] = 2 。

那么怎样高速求解next数组呢?

这里有点动态规划的思想在里面,当中位置 j 等于 0 的 next 值为-1,表示找不到这种最长前缀。 j > 0 时。next值能够通过 j - 1 位置的next值求得。

求解next[ j ]的步骤:

  1. t = next[ j - 1 ] + 1,t 指向可能等于 p[ j ] 的位置,即 p[ t ] 可能等于 p[ j ]。
  2. 假设 p[ t ]   =  p[ j ] , 那么 next[ j ] = next[ j - 1 ] + 1
  3. 假设 p[ t ]  !=  p[ j ] , 则令 t = next[ t - 1 ] + 1,继续第 2 步直到 t = 0 或者找到位置。

  4. 结束时推断p[ t ] 是否等于 p[ j ] ,假设等于则 next[ j ] = t , 否则等于 -1 。

下图表示了第一次不匹配。第二次匹配的过程,其他过程能够类推。当中     或     覆盖部分表示最长匹配串。   为待判定位置,   
为已判定位置。

0123                                                     j

×××××××××××××××××××××××××××××××××××××××××

×××××××××××××××××××××××××××××××××××××××××

2)利用next数组进行最小回溯

s ××××××××××××××××××××××××××××××××××××××××××××

p                                            ××××××××××××××

在j处不失配时,前面的有部分匹配。这时须要利用next数组信息进行最小回溯。

s ××××××××××××××××××××××××××××××××××××××××××××

p                                            ××××××××××××××

(这里 i 指向 s , j 指向 p。)

注意在 j = 0 的时候失配时。直接 i++ 就可以。

当 j > 0 的时候,须要利用next数组最快找到 p[ j ] == s[ i ] 的位置。

假设 j 移动到了0还找不到。则 i++,然后继续匹配。

这里我们能够发现仅仅有 j 回溯了,i没有回溯,可是因为普通版本号的 KMP 算法 j 须要不停地回溯直到找到合适的回溯位置,因此速度不是特别快。还能够继续优化。感兴趣的读者能够想想怎样事先求解好next数组从而不须要不停地回溯。

代码实现

strStr返回的是首次匹配的地址。假设不能匹配则返回NULL。

class Solution {
public:
    vector<int> getNext(char* &s){
        vector<int> next(strlen(s), -1);

        for(int i=1; i<strlen(s); i++){
            int j = next[i-1]; /* 前一个字符的最长匹配长度 */

            while(s[j+1] != s[i] && j>=0)
                j = next[j];

            if(s[j+1] == s[i])
                next[i] = j+1;
            // else 默觉得-1
        }

        return next;
    }

    char *strStr(char *haystack, char *needle) {
        if(haystack==NULL || needle==NULL) return NULL;
        if(strlen(haystack) < strlen(needle)) return NULL;
        if(strlen(needle) == 0) return haystack;

        vector<int> next = getNext(needle);
        int i = 0;
        int j = 0;
        int haystackLen = strlen(haystack);
        int needleLen = strlen(needle);
        while(i<haystackLen && j<needleLen){
            if(haystack[i] == needle[j] ) {
                i++;
                j++;
                if(j == needleLen) return haystack + i - j;
            }else{
                if(j == 0) i++;
                else j = next[j-1]+1; /* 该步骤能够优化 */
            }
        }

        return NULL;
    }
};

因为有人问有没有java版本号的,因为鄙人java比較挫。写java时部分还写成了scala的语法。不知道代码是否规范,有优化的地方还麻烦java方面的大神指点。

import java.util.*;

public class StrStrSolution {
    private List<Integer> getNext(String p){
        List<Integer> next = new ArrayList<Integer>();
        next.add(-1);

        for(int i=1; i<p.length(); i++){
            int j = next.get(i-1);

            while(p.charAt(j+1) != p.charAt(i) && j>=0)
                j = next.get(j);

            if(p.charAt(j+1) == p.charAt(i))
                next.add( j + 1 );
            else
                next.add( -1 );
        }

        return next;
    }

    public String strStr(String haystack, String needle) {
        if (haystack == null || needle == null) return null;
        if (needle.length() == 0) return haystack;
        if (needle.length() > haystack.length()) return null;

        List<Integer> next = getNext(needle);
        int i = 0;
        int j = 0;
        int haystackLen = haystack.length();
        int needleLen = needle.length();
        while(i < haystackLen && j < needleLen){
            if(haystack.charAt(i) == needle.charAt(j) ) {
                i++;
                j++;
                if(j == needleLen) return haystack.substring(i - j);
            }else{
                if(j==0) i++;
                else j = next.get(j-1)+1;
            }
        }  

        return null;
    }

    public static void main(String[] args) {
        String s = "babcabaabcacbac";
        String p = "abaabcac";
        StrStrSolution sol = new StrStrSolution();
        System.out.println(sol.strStr(s,p));
    }
}
时间: 2024-10-06 20:24:29

【数据结构&amp;&amp;等差数列】KMP简介和算法的实现(c++ &amp;&amp; java)的相关文章

【数据结构&amp;&amp;算法系列】KMP算法介绍及实现(c++ &amp;&amp; java)

KMP算法如果理解原理的话,其实很简单. KMP算法简介 这里根据自己的理解简单介绍下. KMP算法的名称由三位发明者(Knuth.Morris.Pratt)的首字母组成,又称字符串查找算法. 个人觉得可以理解为最小回溯算法,即匹配失效的时候,尽量少回溯,从而缩短时间复杂度. KMP算法有两个关键的地方,1)求解next数组,2)利用next数组进行最小回溯. 1)求解next数组 next数组的取值只与模式串有关,next数组用于失配时回溯使用. 在简单版本的KMP算法中,每个位置 j 的 n

Bug2算法的实现(RobotBASIC环境中仿真)

移动机器人智能的一个重要标志就是自主导航,而实现机器人自主导航有个基本要求--避障.之前简单介绍过Bug避障算法,但仅仅了解大致理论而不亲自动手实现一遍很难有深刻的印象,只能说似懂非懂.我不是天才,不能看几遍就理解理论中的奥妙,只能在别人大谈XX理论XX算法的时候,自己一个人苦逼的面对错误的程序问为什么... 下面开始动手来实现一下简单的Bug2避障算法.由于算法中涉及到机器人与外界环境的交互,因此需要选择一个仿真软件.常用的移动机器人仿真软件主要有Gazebo.V-rep.Webots.MRD

软考笔记第六天之各排序算法的实现

对于前面的排序算法,用c#来实现 直接插入排序: 每次从无序表中取出第一个元素,把它插入到有序表的合适位置,使有序表仍然有序.第一趟比较前两个数,然后把第二个数按大小插入到有序表中: 第二趟把第三个数据与前两个数从前向后扫描,把第三个数按大小插入到有序表中:依次进行下去,进行了(n-1)趟扫描以后就完成了整个排序过程.直接插入排序属于稳定的排序,最坏时间复杂性为O(n^2),空间复杂度为O(1).直接插入排序是由两层嵌套循环组成的.外层循环标识并决定待比较的数值.内层循环为待比较数值确定其最终位

Python学习(三) 八大排序算法的实现(下)

本文Python实现了插入排序.基数排序.希尔排序.冒泡排序.高速排序.直接选择排序.堆排序.归并排序的后面四种. 上篇:Python学习(三) 八大排序算法的实现(上) 1.高速排序 描写叙述 通过一趟排序将要排序的数据切割成独立的两部分,当中一部分的全部数据都比另外一部分的全部数据都要小,然后再按此方法对这两部分数据分别进行高速排序,整个排序过程能够递归进行,以此达到整个数据变成有序序列. 1.先从数列中取出一个数作为基准数. 2.分区过程,将比这个数大的数全放到它的右边,小于或等于它的数全

STL简单&lt;stl_algorithms.h&gt;算法的实现

1.简介 STL标准中,没有区分基本算法和复杂算法,然而SGI STL却把常用的算法定义在<stl_algorithms.h>中.本文介绍部分<stl_algorithms.h>算法的实现,给出实现代码和测试代码. 本文介绍的算法包括: 1.      mismatch:比较两个序列,指出两者之间第一个不匹配的点,返回一对迭代器,分别指向两序列中不匹配的点: 2.      equal:如果两个序列在 [first, last ] 区间内相等,equal() 返回true,忽略第二

通用固定长度编码格式的字符串查找算法的实现

通用固定长度编码格式的字符串查找算法的实现 字符串的查找是数据库应用中必不可少的操作,而且每种数据库产品(ORACLE.DB2.SYBASE.MS SQL SERVER.MYSQL等等)也都提供了对应的字符串处理函数,比如DB2的LOCATE函数. 但在实际的工作中,还是会遇到一些特殊情况的处理,这使得直接使用字符串查找函数,得到的结果可能是错误的,比如本文中提到的固定长度编码格式的字符串的查找.值得注意的是,本文提出的算法可以稍加修改即移植到其它关系数据库系统或者前端开发工具中. 在实际数据库

RMQ问题总结,标准RMQ算法的实现

RMQ问题:对于长度为N的序列,询问区间[L,R]中的最值 RMQ问题的几种解法: 普通遍历查询,O(1)-O(N) 线段树,O(N)-O(logN) DP,O(NlogN)-O(1) RMQ标准算法,O(N)-O(1) 简单介绍: 朴素的查询,不需要任何预处理,但结果是没有任何已知的信息可以利用,每次都需要从头遍历到尾. 线段树,区间问题的神器,用线段树做比起朴素的暴力查询要快得多,关键在于线段树使用了分治思想,利用了区间问题的可合并性.任何一个区间最多只需要logN个线段树上的区间来合并,线

七种排序算法的实现和总结

最近把七种排序算法集中在一起写了一遍. 注释里有比较详细的说明. 1 /*排序算法大集合**/ 2 #include <stdio.h> 3 #include <string.h> 4 #include <stdlib.h> 5 6 //------------------快速排序------------------// 7 /* 8 核心: 9 如果你知道多少人该站你前面,多少人站你后面,你一定知道你该站哪个位置. 10 算法: 11 1.选取分界数,参考这个分界数,

STL简单 copy 算法的实现

1.简介 不论是对客户端或对STL内部而言,copy() 都是一个常常被调用的函数.由于copy进行的是复制操作,而复制操作不外乎运用赋值运算符(assignment operator)或复制构造函数(copy constructor),但是某些元素的类型是trivial assignment operator,因此如果能使用内存直接进行复制(例如使用C标准函数memmove.memcpy),便能节约大量时间.为此,copy算法用尽各种办法,包括函数重载(function overloading