字符串匹配(一)----Rabin-Karp算法

题目：假如要判断字符串A"ABA"是不是字符串B"ABABABA"的子串。

解法一：暴力破解法， 直接枚举所有的长度为3的子串，然后依次与A比较,这样就能得出匹配的位置。 这样的时间复杂度是O(M*N)，M为B的长度，N为A的长度。

解法二：Rabin-Karp算法

　　思想：假设待匹配字符串的长度为N，目标字符串的长度为M（M>N）；首先计算待匹配字符串的hash值，计算目标字符串前N个字符的hash值；比较前面计算的两个hash值，比较次数M-N+1：若hash值不相等，则继续计算目标字符串的下一个长度为N的字符子串的hash值，若hash值相同，则需要使用比较字符是否相等再次判断是否为相同的子串(这里若hash值相同，则直接可以判断待匹配字符串是目标字符串的子串，之所以需要再次判断字符是否相等，是因为不同的字符计算出来的hash值有可能相等，称之为hash冲突或hash碰撞，不过这是极小的概率，可以忽略不计)；

　　哈希函数定义如下：

　　　　其中Cm表示字符串中第m项所代表的特地数字，有很多种定义方法，我习惯于用java自带的char值，也就是ASCII码值。java中的char是16位的，用的Unicode编码，8位的ASCII码包含在Unicode中。b是哈希函数的基数，相当于把字符串看作是b进制数。h是防止哈希值溢出。

　　　　

　　代码：

public class RabinKarp {

    public static void main(String[] args) {
        String s = "ABABABA";
        String p = "ABA";
        match(p, s);
    }
    
    /**
     * @param p 模式
     * @param s 源串
     */
    static void match(String p,String s){
        long hash_p = hash(p);//p的hash值
        int p_len = p.length();
        for (int i = 0; i+p_len<= s.length(); i++) {
            long hash_i = hash(s.substring(i, i+p_len));// i 为起点，长度为p_len的子串的hash值
            if (hash_p==hash_i) {
                System.out.println("match:"+i);
            }
        }
    }

    final static long seed = 31;  // 进制数
    
    /**
     * 不同的字符计算出来的hash值相同 称为hash冲突
     * 使用100000个不同字符串产生的冲突数，大概在0~3波动，使用100百万不同的字符串，冲突数大概110+范围波动。
     * @param str
     * @return
     */
    private static long hash(String str) {
        long h = 0;
        for (int i = 0; i !=str.length(); i++) {
            // 这个计算方式就是 An²+Bn+c 的循环表达式，而这个计算方式就是二进制转十进制的计算方式 
            // 这里n=31，可以理解为转为31进制
            h = seed * h + str.charAt(i);
            
        }
        return h%Long.MAX_VALUE;  // 防止hash值过大
    }

}

　　结果：

　　　　

　　在这里计算一下时间复杂度，计算hash值的时间为O(N)，目标字符串长度为M，所以时间复杂度为O(M*N)。好像和暴力破解差不多。下面会通过一种类似于预处理的方式来进行优化，叫做滚动哈希。就是提前计算好源串的hash值，构建成一个hash数组，再通过比较hash值，这样就成功匹配出来了。通过这种优化，时间复杂度下降到O(M+N),O(N)为计算待匹配的字符串计算hash值的时间，O(M)为计算hash数组的时间。

　　滚动哈希的技巧就是：如果已经算出从k到k+m的子串的哈希值H(S[k,k+1...k+m])，那么从k+1到k+m+1的子串的哈希值就可以基于前一个的哈希值计算得出。

　　　　

　　代码：

/**
 * 滚动哈希法
 * 对目标字符串按d进制求值，mod h 取余作为其hash
 * 对源串，一次求出m个字符的hash，保存在数组中(滚动计算)
 * 匹配时，只需对比目标串的hash值和预存的源串的hash值表
 */
public class RabinKarp_1 {

    public static void main(String[] args) {
        String s = "ABABABA";
        String p = "ABA";
        match(p, s);
    }
    
    static void match(String p,String s){
        long hash_p = hash(p);//p的hash值
        long[] hashOfS = hash(s, p.length());
        for (int i = 0; i < hashOfS.length; i++) {
            if (hashOfS[i] == hash_p) {
                System.out.println("match:" + i);
            }
        }
    }

    final static long seed = 31;
    
    /**
     * 滚动哈希
     * @param s 源串
     * @param n 子串的长度
     * @return
     */
    private static long[] hash(String s, int n) {
        long[] res = new long[s.length() - n + 1];
        //前n个字符的hash
        res[0] = hash(s.substring(0, n));
        for (int i = n; i < s.length(); i++) {
          char newChar = s.charAt(i);  // 新增的字符
          char oldchar = s.charAt(i - n);  // 前n字符的第一字符
          //前n个字符的hash*seed-前n字符的第一字符*seed的n次方
          long v = (long) ((res[i - n] * seed + newChar - Math.pow(seed, n) * oldchar) % Long.MAX_VALUE);
          res[i - n + 1] = v;
        }
        return res;
    }

    static long hash(String str) {
        long h = 0;
        for (int i = 0; i != str.length(); ++i) {
          h = seed * h + str.charAt(i);
        }
        return h % Long.MAX_VALUE;
      }
}

　　结果：