数据结构与算法Day26----字符串匹配（二）：BM（Boyer-Moore）算法

一、BM（Boyer-Moore）算法:

1、坏字符规则（bad character rule）:

  从模式串的末尾往前倒着匹配，当发现某个字符没法匹配的时候，就把这个没有匹配的字符叫作坏字符（主串中的字符）。拿坏字符在模式串中查找，发现模式串中并不存在这个字符，也就是说，坏字符与模式串中的任何字符都不可能匹配。这个时候，可以将模式串直接往后滑动模式串的长度位（3），将模式串滑动到坏字符后面的位置，再从模式串的末尾字符开始比较。

2、好后缀规则（good suffix shift）：

  把已经匹配的bc叫作好后缀，记作{u}。然后拿它在模式串中查找，如果找到了另一个跟{u}相匹配的子串{u*}，那么就将模式串滑动到子串{u*}与主串中{u}对齐的位置。

如果好后缀在模式串中不存在可匹配的子串，那在一步一步往后滑动模式串的过程中，只要主串中的{u}与模式串有重合，那肯定就无法完全匹配。但是当模式串滑动到前缀与主串中{u}的后缀有部分重合的时候，并且重合的部分相等的时候，就有可能会存在完全匹配的情况。不仅要看好后缀在模式串中，是否有另一个匹配的子串，还要考察好后缀的后缀子串，是否存在跟模式串的前缀子串匹配的。

3、如何选择用好后缀规则还是坏字符规则，来计算模式串往后滑动的位数？

  分别计算好后缀和坏字符往后滑动的位数，然后取两个数中最大的，作为模式串往后滑动的位数。

4、算法：

<1>、查找坏字符在模式串中出现的位置：

  将模式串中的每个字符及其下标都存到散列表中。用大小为256的数组，来记录每个字符在模式串中出现的位置。数组的下标对应字符的ASCII码值，数组中存储这个字符在模式串中出现的位置。

//变量b是模式串， m是模式串的长度， bc表示散列表。
private static final int SIZE = 256; // 全局变量或成员变量
private void generateBC(char[] b, int m, int[] bc) {
    for (int i = 0; i < SIZE; ++i) {
        bc[i] = -1; // 初始化bc
    }
    for (int i = 0; i < m; ++i) {
        int ascii = (int)b[i]; // 计算b[i]的ASCII值
        bc[ascii] = i;
    }
}

<2>、好后缀规则相关代码：

(1)、表示模式串中不同的后缀子串：

  因为后缀子串的最后一个字符的位置是固定的，下标为m-1，所以只需要记录长度就可以了。通过长度，可以确定一个唯一的后缀子串。
  为了在模式串中查找跟好后缀匹配的另一个子串，引入变量suffix数组，suffix数组的下标k表示后缀子串的长度，下标对应的数组值存储的是在模式串中跟好后缀{u}相匹配的子串{u*}的起始下标值。
  记录模式串的后缀子串是否能匹配模式串的前缀子串，定义一个boolean类型的prefix数组。

  如果公共后缀子串的长度是k，那就记录suffix[k]=j（j表示公共后缀子串的起始下标）。如果j等于0，也就是说，公共后缀子串也是模式串的前缀子串，就记录prefix[k]=true。

// b表示模式串， m表示长度， suffix， prefix数组事先申请好了
private void generateGS(char[] b, int m, int[] suffix, boolean[] prefix) {
    for (int i = 0; i < m; ++i) { // 初始化
        suffix[i] = -1;
        prefix[i] = false;
    }
    for (int i = 0; i < m - 1; ++i) { // b[0, i]
        int j = i;
        int k = 0; // 公共后缀子串长度
        while (j >= 0 && b[j] == b[m-1-k]) { // 与b[0, m-1]求公共后缀子串
            --j;
            ++k;
            suffix[k] = j+1; //j+1表示公共后缀子串在b[0, i]中的起始下标
        }
        if (j == -1) prefix[k] = true; //如果公共后缀子串也是模式串的前缀子串
    }
}

(2)、在模式串跟主串匹配的过程中遇到不能匹配的字符时，根据好后缀规则，计算模式串往后滑动的位数：

  假设好后缀的长度是k。先拿好后缀在suffix数组中查找其匹配的子串。如果suffix[k]不等于-1（-1表示不存在匹配的子串），那就将模式串往后移动jsuffix[k]+1位（j表示坏字符对应的模式串中的字符下标）。

  如果suffix[k]等于-1，表示模式串中不存在另一个跟好后缀匹配的子串片段。好后缀的后缀子串b[r, m-1]（其中， r取值从j+2到m-1）的长度k=m-r，如果prefix[k]等于true，表示长度为k的后缀子串，有可匹配的前缀子串，这样我们可以把模式串后移r位。

  如果上面两条规则都没有找到可以匹配好后缀及其后缀子串的子串，就将整个模式串后移m位。

(3)、BM算法代码实现：

// a,b表示主串和模式串； n， m表示主串和模式串的长度。
public int bm(char[] a, int n, char[] b, int m) {
    int[] bc = new int[SIZE]; // 记录模式串中每个字符最后出现的位置
    generateBC(b, m, bc); // 构建坏字符哈希表
    int[] suffix = new int[m];
    boolean[] prefix = new boolean[m];
    generateGS(b, m, suffix, prefix);
    int i = 0; // j表示主串与模式串匹配的第一个字符
    while (i <= n - m) {
        int j;
        for (j = m - 1; j >= 0; --j) { // 模式串从后往前匹配
            if (a[i+j] != b[j]) break; // 坏字符对应模式串中的下标是j
        }
        if (j < 0) {
            return i; // 匹配成功，返回主串与模式串第一个匹配的字符的位置
        }
        int x = j - bc[(int)a[i+j]];
        int y = 0;
        if (j < m-1) { // 如果有好后缀的话
            y = moveByGS(j, m, suffix, prefix);
        }
        i = i + Math.max(x, y);
    }
    return -1;
}
// j表示坏字符对应的模式串中的字符下标; m表示模式串长度
private int moveByGS(int j, int m, int[] suffix, boolean[] prefix) {
    int k = m - 1 - j; // 好后缀长度
    if (suffix[k] != -1) return j - suffix[k] +1;
    for (int r = j+2; r <= m-1; ++r) {
        if (prefix[m-r] == true) {
            return r;
        }
    }
    return m;
}