BM(Boyer-Moore)算法，非常高效的字符串匹配算法。
BM算法的核心思想
我们把模式串和主串的匹配过程，看作模式串在主串中不停地往后滑动。当遇到不匹配的字符时，BF 算法和 RK 算法的做法是，模式串往后滑动一位，然后从模式串的第一个字符开始重新匹配。
BM算法就是寻找在字符串中出现的规律。有时候就会跳过一些肯定不会匹配的情况。
BM算法原理：包含两部分,坏字符规则和好后缀规则。
坏字符规则:我们从模式串的末尾向前倒着匹配，当我们发现某个字符没法匹配的时候，我们就称这个字符为坏字符(主串中的字符).
我们拿坏字符 c 在模式串中查找，发现模式串中并不存在这个字符。这个时候，我们可以将模式串直接往后滑动三位，将模式串滑动到 c 后面的位置，再从模式串的末尾字符开始比较。
当发生不匹配的时候，我们把坏字符对应的模式串中的字符下标记作 si。如果坏字符在模式串中存在，我们把这个坏字符在模式串中的下标记作 xi。如果不存在，我们把 xi 记作 -1。那模式串往后移动的位数就等于 si-xi。（注意，我这里说的下标，都是字符在模式串的下标）。
还需要用到好后缀规则:
从后往前逐位比较模式串与主串的字符，当出现坏字符时停止。若存在已匹配成功的子串｛u｝，那么在模式串的｛u｝前面找到最近的｛u｝，记作｛u’｝。再将模式串后移，使得模式串的｛u’｝与主串的｛u｝重叠。若不存在｛u’｝，则直接把模式串移到主串的｛u｝后面。为了没有遗漏，需要找到最长的、能够跟模式串的前缀子串匹配的，好后缀的后缀子串（同时也是模式串的后缀子串）。然后把模式串向右移到其左边界，与这个好后缀的后缀子串在主串中的左边界对齐。
在模式串中，查找跟好后缀匹配的另一个子串；
在好后缀的后缀子串中，查找最长的、能跟模式串前缀子串匹配的后缀子串；
因为后缀子串的最后一个字符的位置是固定的，下标为 m-1，我们只需要记录长度就可以了。通过长度，我们可以确定一个唯一的后缀子串。
BM 算法核心思想是，利用模式串本身的特点，在模式串中某个字符与主串不能匹配的时候，将模式串往后多滑动几位，以此来减少不必要的字符比较，提高匹配的效率。BM 算法构建的规则有两类，坏字符规则和好后缀规则。好后缀规则可以独立于坏字符规则使用。因为坏字符规则的实现比较耗内存，为了节省内存，我们可以只用好后缀规则来实现 BM 算法。
可以查看BM算法文档中的图挺好的。
http://www.cs.jhu.edu/~langmea/resources/lecture_notes/boyer_moore.pdf
package LeetCode;
public class BM {
private static final int SIZE = 256;
private static 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;
}
}
public static int bm(char[] a,int n,char[] b,int m) {
int[] bc = new int[SIZE]; //记录模式串中每个字符最后出现的位置
generateBC(b, m, bc); //侯建坏字符哈希表
int i = 0; // i表示主串和模式串对齐的第一个字符
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; //匹配成功，返回模式串与主串第一个匹配的字符的位置
}
//这里等同于将模式串往后滑动 j -bc[(int)a[i+j]]位
i = i + (j - bc[(int) a[i + j]]);
}
return -1;
}
// b 表示模式串，m 表示长度，suffix，prefix 数组事先申请好了
private static 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; // 如果公共后缀子串也是模式串的前缀子串
}
}
// a,b 表示主串和模式串；n，m 表示主串和模式串的长度。
public static int bmEnd(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 static 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;
}
public static void main(String[] args) {
String a = "qwertyuiop";
String b = "tqw";
char[] A = a.toCharArray();
char[] B = b.toCharArray();
System.out.println(bmEnd(A,A.length,B,B.length));
}
}
KMP算法
KMP 算法的核心思想，跟上一节讲的 BM 算法非常相近。我们假设主串是 a，模式串是 b。在模式串与主串匹配的过程中，当遇到不可匹配的字符的时候，我们希望找到一些规律，可以将模式串往后多滑动几位，跳过那些肯定不会匹配的情况。
我们只需要拿好前缀本身，在它的后缀子串中，查找最长的那个可以跟好前缀的前缀子串匹配的。假设最长的可匹配的那部分前缀子串是{v}，长度是 k。我们把模式串一次性往后滑动 j-k 位，相当于，每次遇到坏字符的时候，我们就把 j 更新为 k，i 不变，然后继续比较。
好前缀的所有后缀子串中，最长的可匹配前缀子串的那个后缀子串，叫做最长可匹配后缀子串，对应的前缀子串，叫做最长可匹配前缀子串。
next数组的含义就是一个固定字符串的最长前缀和最长后缀相同的长度。
最长前缀：是说以第一个字符开始，但是不包含最后一个字符。
对于目标字符串ababaca，长度是7，所以next[0]，next[1]，next[2]，next[3]，next[4]，next[5]，next[6]分别计算的是 a，ab，aba，abab，ababa，ab abac，aba baca 的相同的最长前缀和最长后缀的长度。由于a，ab，aba，abab，ababa，ababac，ababaca的相同的最长前缀和最长后缀是“”，“”，“a”，“ab”，“aba”，“”，“a”,所以next数组的值是[-1,-1,0,1,2,-1,0]，这里-1表示不存在，0表示存在长度为1，2表示存在长度为3。这是为了和代码相对应。
可以阅读这篇博文
https://blog.csdn.net/starstar1992/article/details/54913261
package LeetCode;
public class KMP {
//a,b分别是主串和模式串，n,m分别是主串和模式串的长度
public static int kmp(char[] a,int n,char[] b,int m){
int[] next = getNexts(b,m);
int j=0;
for(int i=0;i<n;i++){
while(j > 0 && a[i] != b[j]){// 一直找到a[i]和b[j]]]
j = next[j-1] + 1;
}
if(a[i] == b[j]){
++j;
}
if(j == m){//找到模式匹配串了
return i - m +1;
}
}
return -1;
}
private static int[] getNexts(char[] b, int m) {
//next数组的含义就是一个固定字符串的最长前缀和最长后缀相同的长度。
int[] next = new int[m];
next[0] = -1;
int k = -1;
for (int i=1;i<m;++i){
while(k != -1 && b[k+1] != b[i]){
k = next[k];
}
if(b[k+1] == b[i]){
++k;
}
next[i] = k;
/* next[i] = k
因为前一个的最长串的下一个字符不与最后一个相等，需要找前一个的次长串，问题就变成了求0到next(k)的最长串，
如果下个字符与最后一个不等，继续求次长串，也就是下一个next(k)，直到找到，或者完全没有*/
}
return next;
}
public static void main(String[] args) {
String a = "abcdabcdcacdcd";
String b = "cbcbc";
char[] A = a.toCharArray();
char[] B = b.toCharArray();
System.out.println(kmp(A,A.length,B,B.length));
}
}