Rabin-Karp 指纹字符串查找算法

Rabin-Karp 指纹字符串查找算法

M.O.Rabin 和 R.A.Karp 发明了一种完全不同的基于散列的字符串查找算法。我们需要计算模式字符串的散列函数,然后用相同的散列函数计算文本中所有可能的 M 个字符的子字符串散列值并寻找匹配。如果找到了一个散列值和模式字符串相同的子字符串,那么再继续验证两者是否匹配。这个过程等价于将模式保存在一张散列表中,然后在文本的所有子字符串中进行查找。但不需要为散列表预留任何空间,因为它只会含有一个元素。根据这段描述直接实现的算法将会比暴力子字符串查找算法慢很多(因为计算散列值将会涉及字符串中的每个字符, 成本比直接比较这些字符要高得多)。 Rabin 和 Karp 发明了一种能够在常数时间内算出 M 个字符的子字符串散列值的方法(需要预处理),这样就得到了在实际应用中的运行时间为线性级别的字符串查找算法。

基本思想

长度为 M 的字符串对应着一个 R 进制的 M 位数。为了用一张大小为 Q 的散列表来保存这种类型的键,需要一个能够将 R 进制的 M 位数转化为一个 0 到 Q-1 之间的 int 值散列函数。除留余数法是一个很好的选择:将该数除以 Q 并取余。在实际应用中会使用一个随机的素数 Q,在不溢出的情况下选择一个尽可能大的值。(因为我们并不会真的需要一张散列表。)理解这个方法最简单的办法就是取一个较小的 Q 和 R=10 的情况,如下所示。要在文本3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3中找到模式 2 6 5 3 5,首先要选择散列表的大小 Q(在这个例子中是 997),则散列值为26535 % 997 = 613,然后计算文本中所有长度为 5 个数字的子字符串的散列值并寻找匹配。在这个例子中,在找到 613 的匹配之前,得到的散列值分别为 508、 201、 715、 971、 442 和 929,如下图所示:
在这里插入图片描述

计算函数散列

对于 5 位的数值,只需使用 int 值即可完成所有所需的计算。但如果 M 是 100 或者1000 怎么办?这里使用的是 Horner 方法,代码如下面所示。这段代码计算了用 char 值数组表示的 R 进制的 M 位数的散列函数,所需时间与 M 成正比。(将 M 作为参数传递给该方法,这样就可以将它同时用于模式字符串和正文。)对于这个数中的每一位数字,将散列值乘以 R,加上这个数字,除以 Q 并取其余数。例如,这样计算示例模式字符串散列值的过程如下图解所示。我们也可以用同样的方法计算文本中的子字符串散列值,但这样一来字符串查找算法的成本就将是对文本中的每个字符进行乘法、加法和取余计算的成本之和。在最坏情况下这需要 NM 次操作,相对于暴力子字符串查找算法来说并没有任何改进。

Horner方法,用于除留余数法计算散列值

private long stringHash(String str,int m){
        long hash = 0;
        for(int i = 0; i < m; i++){
            hash = (hash * R + str.charAt(i)) % Q;
        }
        return hash;
}

使用 Horner 方法计算模式字符串的散列值图解

在这里插入图片描述

关键思想

Rabin-Karp 算法的基础是对于所有位置 i,高效计算文本中i+1 位置的子字符串散列值。这可以由一个简单的数学公式得到。我们用 t i t_i ti 表示txt.charAt(i),那么文本 txt 中起始于位置 i 的
含有 M 个字符的子字符串所对应的数即为:

x i = t i R M − 1 + t i + 1 R M − 2 + . . . + t i + M − 1 R 0 x_i = t_iR^{M-1} + t_{i+1}R^{M-2} + ... + t_{i+M-1}R^0 xi=tiRM1+ti+1RM2+...+ti+M1R0

假设已知 h( x i x_i xi)= x i x_i xi mod Q 。将模式字符串右移一位即等价于将 x i x_i xi 替换为:

x i + 1 = ( x i − t i R M − 1 ) R + t i + M x_{i+1} = (x_i - t_iR^{M-1})R + t_{i+M} xi+1=(xitiRM1)R+ti+M

即将它减去第一个数字的值,乘以 R,再加上最后一个数字的值。现在,关键的一点在于不需要保存这些数的值,而只需要保存它们除以 Q 之后的余数。取余操作的一个基本性质是如果在每次算术操作之后都将结果除以 Q 并取余,这等价于在完成了所有算术操作之后再将最后的结果除以 Q 并取余。曾经在用 Horner 方法实现除留余数法时利用过这个性质。这么做的结果就是无论 M 是 5、100 还是 1000,都可以在常数时间内高效地不断向右一格一格地移动 。

图解

在这里插入图片描述

蒙特卡罗法

在文本 txt 中找到散列值与模式字符串相匹配的一个 M 个字符的子字符串之后,你可能会逐个比较它们的字符以确保得到了一个匹配而非相同的散列值。 我们不会这么做,因为这需要回退文本指针。作为替代,这里将散列表的“规模” Q 设为任意大的一个值,因为我们并不会真构造一张散列表而只是希望用模式字符串验证是否会产生冲突。我们会取一个大于 1 0 20 10^{20} 1020 的 long 型值,使得一个随机键的散列值与模式字符串冲突的概率小于 1 0 − 20 10^{-20} 1020。这是一个极小的值。如果它还不够小,你可以将这种方法运行两遍,这样失败的几率将会小于 1 0 − 40 10^{-40} 1040。这是蒙特卡洛算法一种著名早期应用,它既能够保证运行时间,失败的概率又非常小。检查匹配的其他方法可能很慢(性能有很小的概率相当于暴力算法)但能够确保正确性。这种算法被称为拉斯维加斯算法。

实现

实现类

package com.design.string;

/**
 * Rabin-Karp 指纹查找算法
 *
 *  @author hh
 *  @date 2022-1-2 22:37
 */
public class RabinKarp {

    /**
     * 进制
     */
    private int R = 26;

    /**
     * 一个很大的素数
     */
    private long Q = 200000111111111L;

    /**
     * 模式串长度
     */
    private int M;

    /**
     * 模式串的哈希
     */
    private long patHash;

    /**
     * R ^ M % Q
     */
    private long RM;


    public RabinKarp(String pattern) {
        this.M = pattern.length();
        this.RM = 1;
        for(int i = 0; i < this.M; i++){
            this.RM = this.RM * this.R % this.Q;
        }
        this.patHash = this.stringHash(pattern,M);
    }

    private long stringHash(String str,int m){
        long hash = 0;
        for(int i = 0; i < m; i++){
            hash = (hash * R + str.charAt(i)) % Q;
        }
        return hash;
    }

    public int search(String text){
        //文本比模式串还短
        int n = text.length();
        if(n < M){
            return -1;
        }
        long tempHash = this.stringHash(text,M);
        //一开始就匹配
        if(tempHash == this.patHash){
            return 0;
        }
        for(int i = M; i < n; i++){
            tempHash = tempHash * R % Q - text.charAt(i - M ) * RM  % Q + text.charAt(i);
            tempHash = tempHash % Q;
            if(this.patHash == tempHash){
                return i - M  + 1;
            }
        }
        return -1;
    }
}

测试类

package com.design.string;

public class RabinKarpTest {

    public static void main(String[] args){
        String pat = "sheet";
        RabinKarp rabinKarp = new RabinKarp(pat);
        System.out.println(rabinKarp.search("ssheet"));
        System.out.println(rabinKarp.search("sheeet"));
    }
}

测试结果

在这里插入图片描述

参考文档

  • 《算法(第4版)》5.3.5节 Rabin-Karp 指纹字符串查找算法
  • 3
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
串匹配是指在一个文本串中查找另一个模式串的过程。常用的串匹配算法有Naïve算法、Rabin-Karp算法和Knuth-Morris-Pratt算法。 1. Naïve算法 Naïve算法是最简单的串匹配算法,也称为暴力匹配算法。它的思路是从文本串的第一个字符开始,依次比较文本串中的每个字符是否与模式串中的字符相等。若不相等,则继续向后比较;若相等,则比较下一个字符,直到找到完全匹配的子串或文本串被匹配完为止。 Naïve算法的时间复杂度是O(mn),其中m和n分别是模式串和文本串的长度。当模式串和文本串长度相等时,最坏情况下时间复杂度达到O(n^2)。 2. Rabin-Karp算法 Rabin-Karp算法是一种基于哈希值的串匹配算法。它的思路是先将模式串和文本串都转换为哈希值,然后比较它们的哈希值是否相等。如果哈希值相等,则再逐个比较模式串和文本串中的字符是否相等。这种方法可以有效地减少比较次数,提高匹配效率。 Rabin-Karp算法的时间复杂度是O(m+n),其中m和n分别是模式串和文本串的长度。但是,由于哈希函数的不完全性和哈希冲突的存在,Rabin-Karp算法在某些情况下可能会出现误判。 3. Knuth-Morris-Pratt算法 Knuth-Morris-Pratt算法是一种基于前缀函数的串匹配算法。它的思路是先计算出模式串的前缀函数,然后利用前缀函数的信息来跳过已经匹配过的部分,减少比较次数。 具体来说,KMP算法在匹配过程中维护一个指针i和一个指针j,其中i指向文本串中当前匹配的位置,j指向模式串中当前匹配的位置。如果当前字符匹配成功,则i和j同时向后移动一位;如果匹配失败,则通过前缀函数计算出j需要跳转到的位置,使得前j-1个字符与文本串中的对应字符已经匹配成功,然后将j指向这个位置,i不变,继续比较下一个字符。 KMP算法的时间复杂度是O(m+n),其中m和n分别是模式串和文本串的长度。由于利用了前缀函数的信息,KMP算法可以在最坏情况下达到O(n)的时间复杂度,比Naïve算法和Rabin-Karp算法更加高效。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值