Java实现算法导论中Rabin-Karp字符串匹配算法

Rabin-Karp算法的思想：

1. 假设子串的长度为M,目标字符串的长度为N
2. 计算子串的hash值
3. 计算目标字符串中每个长度为M的子串的hash值（共需要计算N-M+1次）
4. 比较hash值
5. 如果hash值不同，字符串必然不匹配，如果hash值相同，还需要使用朴素算法再次判断

1. public static void RabinKarpAlogrithm(char[] T,char[] P, int d,int q){

2. int n=T.length;

3. int m=P.length;

4. if( n < m) return ;

5. int h = 1;

6. for(int i=1; i<=m-1; i++) // 计算高度 h

7. h = h*d%q;//m-1个d相乘然后模q

8. //预处理，计算p， t0

9. int p=0, t=0;

10. for(int i=0; i<m; i++) {

11. p = (( d*p + P[i]) % q);

12. t = (( d*t + T[i]) % q);

13. }

14. //开始匹配

15. for(int s=0; s <n-m+1; s++) {

16. if( p == t ){

17. int i=0;

18. for(i=0; i<m; i++)// 进一步验证

19. if(P[i]!=T[s+i])

20. break;

21. if(i==m) System.out.println("Pattern ocurs with shift:"+s);

22. }

23. if( s < n-m )

24. t= (d* (t - T[s]*h%q) + T[s+m]) % q; // 计算ts+1

25. }

26. System.out.println("string matching ends");

27. }

28. public static void main(String[] args){

29. String strT="2359023141526739921";

30. String strP="31415";

31. char[] T=strT.toCharArray();

32. char[] P=strP.toCharArray();

33. int d=10;

34. int q=13;

35. RabinKarp.RabinKarpAlogrithm(T,P,d,q);

36. }

 

 

package b.a.leetcode;

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;    //字母表的大小
    private long RM;    //R^(M-1) % Q

    public RabinKarp(char[] pat, int R) {
        this.pat = String.valueOf(pat);
        this.R = R;
    }

    public RabinKarp(String pat) {
        this.pat = pat;
        R = 256;
        M = pat.length();
        Q = longRandomPrime();

        RM = 1;
        for (int i = 1; i <= M - 1; i++) {
            RM = (R * RM) % Q;
        }
        patHash = hash(pat, M);
    }

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

    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 static long longRandomPrime() {
        BigInteger prime = BigInteger.probablePrime(31, new Random());
        return prime.longValue();
    }

    public int search(String txt) {
        int N = txt.length();
        if (N < M) return N;
        long txtHash = hash(txt, M);

        if ((txtHash == patHash) && check(txt, 0)) return 0;
        for (int i = M; i < N; i++) {
            txtHash = (txtHash + Q - RM * txt.charAt(i - M) % Q) % Q;
            txtHash = (txtHash * R + txt.charAt(i)) % Q;
            int offset = i - M + 1;
            if ((patHash == txtHash) && check(txt, offset))
                return offset;
        }
        return N;
    }

}