1、朴素的模式匹配算法
朴素的模式匹配算法：就是对主串的每个字符作为子串开头，与要连接的字符串进行匹配。对主串做大循环，每个字符开头做T的长度的小循环，直到成功匹配或全部遍历完成为止。
又称BF算法
package com.alice.dataStructe5.bf; /**
* 返回子串t在主串s中第pos个字符之后的位置，若不存在，则返回-1
* @author Administrator
*
*/
public class BF { public int index(String s,String t){ char ch1[] =s.toCharArray();
char ch2[] = t.toCharArray();
int i = 0;//主串的pos位置开始
int j = 0;//j用于子串开始的下表
while(i<ch1.length && j<ch2.length){//若i小于s长度且j小于t长度时循环
if(ch1[i]==ch2[j]){//两个字母相等则继续
i++;
j++;
}else{//指针后退重新开始匹配
i = i-j+1;//i退回到上次匹配首位的下一个位置
j=0;//退回到子串t的首位
}
}
if(j==ch2.length){
return i-j+1;//返回子串t在主串s中第pos个字符之后的位置
}else{
return -1;//不存在，则返回-1
} } public static void main(String args[]){
BF bf = new BF(); System.out.println(bf.index("hellolo", "lo"));
System.out.println(bf.index("goooglegoogle", "goog")); } }
2、KMP模式匹配算法
这个算法，可以大大避免重复遍历的情况。
在朴素的模式匹配算法中，主串的i值是不断回溯的。KMP 模式匹配算法就是为了让这种没有必要的回溯不发生。
KMP模式匹配算法的重要点在于，寻找next数组。
next数组：当模式匹配中T失配时，next数组对应的元素指定应用T串的哪个元素进行下一轮匹配。
KMP模式匹配算法的实现代码：
package com.alice.dataStructe5.kmp;
import java.util.Arrays;
public class KMP {
public int[] getNext(char[] ch){
int i = 0;//后缀
int j = -1;//前缀
int[] next = new int[ch.length];
next[0] = -1;
while(i < ch.length-1){
if( j == -1|| ch[i]==ch[j]){//ch[i]表示后缀的单个字符，ch[j]表示前缀的单个字符
i++;
j++;
next[i] = j;
}else{
j = next[j];//若字符不相等，j值回溯
}
}
System.out.println(Arrays.toString(next));
return next;
}
public void getNext1() {
int j = 0, k = -1;
String s="ababaaaba";
char []c=s.toCharArray();
int[] next1 = new int[c.length];
next1[0] = -1;
while (j < c.length - 1) {
if (-1 == k || c[j] == c[k]) {
j++;
k++;
next1[j] = k;
} else {
k = next1[k];
}
}
System.out.println(Arrays.toString(next1));
}
public int Index_KMP(String str, String sub) {
char[] ch1 = str.toCharArray();
char[] ch2 = sub.toCharArray();
int i = 0;
int j = 0;
int index = 0;
int[] nextArray = null;
nextArray = getNext(ch2);
while(i <ch1.length && j<ch2.length){
if(ch1[i] == ch2[j] || j==0){
i++;
j++;
}else{
j = nextArray[j];
}
}
if(j >= ch2.length){
index = i-ch2.length;
}else{
index = -1;
}
return index;
}
public static void main(String args[]){
KMP kmp = new KMP();
// kmp.Index_KMP("abcabx", "ab");
String str = "abcabx";
char[] ch = str.toCharArray();
kmp.getNext(ch);
int a=kmp.Index_KMP("aaaabcdefaaaaax", "aaaaax");
System.out.println("a的值为："+a);
// kmp.getNext1();
// System.out.println(kmp.Index_KMP("goooglegoogle", "goog"));
System.out.println(kmp.Index_KMP("ababcabcacbab", "abcac"));
}
}
KMP算法的时间复杂度为O(N+M),相对于模式匹配算法O((n-m+1)*m)来说，更好一些
3、改进的KMP算法
package com.alice.dataStructe5.kmp;
import java.util.Arrays;
public class KMPImproved {
/**
* 改进的KMP算法中，得到nextval数组的方法,用于指导下个元素进行下一轮匹配
* @param ch子串数组
* @return
*/
public int[] getNextval(char[] ch){
int j = -1;
int i = 0;
int[] nextval = new int[ch.length];
nextval[0] = -1;
while(i < ch.length-1){
if(j==-1 || ch[i] == ch[j]){//ch[i]表示后缀的单个字符，ch[j]表示前缀的单个字符
i++;
j++;
if(ch[i] != ch[j]){//若当前字符与前缀字符不匹配
nextval[i] = j;//则当前的j为nextval在i位置的值
}else{
nextval[i] = nextval[j];//如果与前缀字符相等，则将前缀字符的nextval赋值给nextval在i位置的值
}
}else{
j = nextval[j];
}
}
System.out.println(Arrays.toString(nextval));
return nextval;
}
public int getKMP(String s,String t){
char[] ch1 = s.toCharArray();//将字符串转为数组
char[] ch2 = t.toCharArray();//将字符串转为数组
int i = 0;
int j = 0;
int index = 0;
int[] nextval = getNextval(ch2);//定义数组nextval[],通过getNextval()方法得到
while(i < ch1.length && j < ch2.length){//若i小于ch1的长度且j小于ch2的长度，循环继续
if(j==0 || ch1[i] == ch2[j]){//两字符相等，则继续
i++;
j++;
}else{//指针后退重新进行下一轮匹配
j = nextval[j];//j值退回到合适的位置，i值不变
}
}
if(j >= ch2.length){
index = i-ch2.length;//返回子串第一次出现在主串的位置
}else{
index = -1;
}
return index;
}
public static void main(String args[]){
KMPImproved kmpImproved = new KMPImproved();
String t = "ababaaaba";
kmpImproved.getNextval(t.toCharArray());
System.out.println(kmpImproved.getKMP("ababcabcacbab", "abcac"));;
}
}
