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));
}
}