Rabin-Karp字符串查找算法

1.简介
　　暴力字符串匹配（brute force string matching）是子串匹配算法中最基本的一种，它确实有自己的优点，比如它并不需要对文本（text）或模式串（pattern）进行预处理。然而它最大的问题就是运行速度太慢，所以在很多场合下暴力字符串匹配算法并不是那么有用。我们需要一些更快的方法来完成模式匹配的工作，然而在此之前，我们还是回过头来再看一遍暴力法匹配，以便更好地理解其他子串匹配算法。
　　如下图所示，在暴力字符串匹配里，我们将文本中的每一个字符和模式串的第一个字符进行比对。一旦我们找到了一个匹配，我们就将文本中下一个字符取出来和模式串的第二个字符进行比较。

　　该算法运行速度慢的主要原因有二：一方面，我们需要对文本中的每个字符都进行比对；另一方面，即使我们发现模式串首字符和文本中的某个字符相匹配， 我们仍然需要对模式串中剩下的所有符号（字符）挨个进行比对，才知道它们是不是出现在接下来的文本中。那么，是否有别的方法可以用来判断文本是否包含模式串呢？

　　暴力字符串匹配代码：

public class NaiveStringMatch {
    public static int Search(String pat, String txt) {
        int M = pat.length();
        int N = txt.length();

        for (int i = 0; i <= N - M; i++) {
            int j;
            for (j = 0; j < M; j++) {
                if (txt.charAt(i + j) != pat.charAt(j))
                    break;
            }
            if (j == M)
                return i;
        }
        return -1;
    }
    public static int canBackSearch(String pat, String txt) {
        int j, M = pat.length();
        int i, N = txt.length();

        for (i = 0, j = 0; i < N & j < M; i++) {
            if (txt.charAt(i) == pat.charAt(j))
                j++;
            else {
                i -= j;
                j = 0;
            }
        }
        if (j == M)
            return i - M;
        else
            return -1;
    }
}

　　答案是肯定的，确实存在一种更快的方法。为了避免挨个字符对文本和模式串进行比较，我们可以尝试一次性判断两者是否相等。因此，我们需要一个好的哈希函数（hash function）。通过哈希函数，我们可以算出模式串的哈希值，然后将它和文本中的子串的哈希值进行比较。这里有一个问题，我们必须保证该哈希函数能够对一个较长的字符串返回较短的哈希值。然而，我们又不能指望较长的模式串能得到较短的哈希值。但除此之外，这个新方法在速度上应该能比暴力法有显著提升。这种更快的方法就是Rabin-Karp算法。
概述
　　Michael O. Rabin和Richard M. Karp在1987年提出一个想法，即可以对模式串进行哈希运算并将其哈希值与文本中子串的哈希值进行比对。总的来说这一想法非常浅显，唯一的问题在于我们需要找到一个哈希函数 ，它需要能够对不同的字符串返回不同的哈希值。例如，该哈希函数可能会对每个字符的ASCII码进行算，但同时我们也需要仔细考虑对多语种文本的支持。
　　哈希算法可以有很多种不同的形式，它可能包含ASCII码字符以便对数字进行转化，但也可能是别的形式。我们唯一需要的就是将一个字符串（模式串） 转化成为能够快速进行比较的哈希值。以"hello world"为例，假设它的哈希值hash('hello world')=12345。那么如果hash('he')=1，那么我们就可以说模式串"he"包含在文本"hello world"中。由此，我们可以每次从文本中取出长度为m（m为模式串的长度）的子串，然后将该子串进行哈希，并将其哈希值与模式串的哈希值进行比较。
实现
　　算法的基本思想是：长度为M的字符串对应着一个R进制的M位数。Rabin-Karp 算法（以下简称为 RK 算法），是基于这样的思路：即把串看作是字符集长度d进制的数，由数的比较得出字符串的比较结果。例如，给定字符集为∑ ={0,1,2,3,4,5,6,7,8,9} ，∑长度为d=10 ，那么任何以∑为字符集的串都可看作d（此处为 10）进制的数。记模式串P[0..n-1]对应的数值为P，T[0..n-1]所有长度为m的子串对应的数值为ts，设P 和T都是基于字符集长度为| ∑ |=d的字符串。那么， ts即为T[s..s+m]对应的数值，这里 0<=s<=n-m-1 。
　　P= P[m]+d*(P[m-1]+d*(P[m-2]+..)))

　　同样 t0 也可类似求得。最重要的是如何从ts求出 ts+1 。ts+1=T[s+m]+d*(ts -d^(m-1）*T[s])。T[s]
　　注：此处是该算法的关键，即在常数时间内能够计算出下一个 m 长度的字串对应的数值。

import java.math.BigInteger;
import java.util.Random;

public class RabinKarp {
    private String pat;
    private long patHash;
    private int M;
    private long Q;
    private int R = 256;
    private long RM;// R^(M-1)%Q

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

    public boolean check(String txt, int i) {
        for (int j = 0; j < M; j++)
            if (pat.charAt(j) != txt.charAt(i + j))
                return false;
        return true;
    }

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

    private int serach(String txt) {
        int N = txt.length();
        long texHash = hash(txt, M);
        if (patHash == texHash && check(txt, 0))
            return 0;
        for (int i = M; i < N; i++) {
            texHash = (texHash + Q - RM * txt.charAt(i - M) % Q) % Q;
            texHash = (texHash * R + txt.charAt(i)) % Q;
            if (patHash == texHash) {
                if (check(txt, i - M + 1))
                    return i - M + 1;
            }
        }
        return N;
    }

    private static long longRandomPrime() {
        BigInteger prime = BigInteger.probablePrime(31, new Random());
        return prime.longValue();
    }
}

多模式匹配
　　Rabin-Karp算法非常适用于多模式匹配（multiple pattern match）。事实上，它天生就是能够支持此类的操作，这也是它相对于其他字符串查找算法的优势。
算法复杂度
　　Rabin-Karp算法的复杂度是O(nm)，其中n和m分别是文本和模式串的长度。那么它到底比暴力匹配好在哪儿呢？暴力匹配法的算法复杂度同样是O(nm)，这样看起来Rabin-Karp算法在性能上并没有多大提升。然后在实际使用过程中，Rabin-Karp的复杂度通常被认为是 O(n+m)。这就使得它比暴力匹配法要快一些，具体见下图。
　　需要注意的是Rabin-Karp算法需要O(m)的预处理时间。
　　译者注：事实上，由于哈希函数无法保证对不同的字符串产生不同的哈希值，有哈希冲突的现象存在，所以即使模 式串的哈希值和文本子串的哈希值相等，也需要对这两个长度为m的字符串进行额外的比对（当然，如果不相等也就不用比对了，其实大部分的时间省在这上面）， 这时比对的开销是O(m)。最坏情况下，文本中所有长度为m的子串(一共n-m+1个)都和模式串匹配，所以算法复杂度为O((n-m+1)m)。然而实 际情况下，需要进一步比对的子串个数总是有限的（假设为c个），那么算法的期望匹配时间就变成O((n-m+1)+cm)=O(n+m)。
应用
　　我们已经看到Rabin-Karp算法比暴力匹配法其实也快不了太多，那它的应用场景到底是哪里？
　　译者注：原文没有给出具体答案。要回答这个问题，需要先了解Rabin-Karp算法被称道和诟病的原因。然后根据自己的具体应用需要来做判断。
　　Rabin-Karp算法被称道的三个原因

• 它可以用来检测抄袭，因为它能够处理多模式匹配
• 虽然在理论上并不比暴力匹配法更优，但在实际应用中它的复杂度仅为O(n+m);
• 如果能够选择一个好的哈希函数，它的效率将会很高，而且也易于实现。

　　Rabin-Karp算法被诟病的两个原因

1. 有许多字符串匹配算法的复杂度小于O(n+m)；
2. 有时候它和暴力匹配法一样慢，并且它需要额外空间。