一、BF匹配
BF算法中的BF是Brute Force的缩写，中文叫作暴力匹配算法，也叫朴素匹配算法。
BF算法的时间复杂度很高，是O(nm)，但在实际的开发中，它却是一个比较常用的字符串匹配算法。
第一，实际的软件开发中，大部分情况下，模式串和主串的长度都不会太大。而且每次模式串与主串中的子串匹配的时候，当中途遇到不能匹配的字符的时候，就可以就停止了，不需要把m个字符都对比一下。所以，尽管理论上的最坏情况时间复杂度是O(nm)，但是，统计意义上，大部分情况下，算法执行效率要比这个高很多。
第二，朴素字符串匹配算法思想简单，代码实现也非常简单。简单意味着不容易出错，如果有bug也容易暴露和修复。在工程中，在满性性能要求的前提下，简单是首选。
public class BFMate {
public static void main(String[] args) {
BFMate("adjhkljabclkffkk","abc");
}
public static boolean BFMate(String mainStr,String modelStr) {
int len = mainStr.length()-modelStr.length();
for(int i=0;i<len;i++) {
if(modelStr.equals(mainStr.substring(i, i+modelStr.length()))) {
System.out.println("main=="+mainStr.substring(i, i+modelStr.length()));
return true;
}
}
return false;
}
}
二、BM匹配
BM（Boyer-Moore）算法。它是一种非常高效的字符串匹配算法。
BM算法核心思想是，利用模式串本身的特点，在模式串中某个字符与主串不能匹配的时候，将模式串往后多滑动几位，以此来减少不必要的字符比较，提高匹配的效率。BM算法构建的规则有两类，字符规则和好后缀规则。好后缀规则可以独立于坏字符规则使用。因为坏字符规则的实现比较耗内存，为了节省内存，我们可以只用好后缀规则来实现BM算法。
public class BMMate {
private final int Size = 256;
public 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;//b[i]在bc中的位置
}
}
//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]中的起始下标
System.out.println("i="+i+",j="+j);
System.out.println("suffix"+k+"="+suffix[k]);
}
if(j==-1) {
prefix[k] = true;//如果公共后缀子串也是模式串的前缀子串
System.out.println("prefix"+k+"="+prefix[k]);
}
}
}
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;//表示主串与模式串第一个字符对齐
while(i<n-m) {
int j=0;
for(j=m-1;j>=0;j--) {//模式串从后往前匹配
if(a[i+j] != b[j]) break;
}
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;
}
}
三、Trie树
Trie树，也叫“字典树”。顾名思义，它是一个树形结构。它是一种专门处理字符串匹配的数据结构，用来解决在一组字符串集合中快速查找某个字符串的问题。
/**
* 假设插入的数据只包含26个小写字母组成的单词
* 将26个字母映射的一个长度26的数组中，下标0-25分别对应a-z
*
* 插入字符串时间复杂度 : O(n),n表示所有字符串的长度和
* 查找字符串时间复杂度 : O(k),k表示要查找的字符串的长度
*
* Trie树不适合精确匹配查找，这种问题更适合用散列表或者红黑树来解决。
* Trie树比较适合的是查找前缀匹配的字符串，类似实现搜索关键词的提示功能。
*/
public class TrieTree {
private TrieNode root = new TrieNode('/');//存储无意义字符串
public class TrieNode {
public char data;
public TrieNode[] children = new TrieNode[26];
public boolean isEndingChar;
public TrieNode(char data) {
this.data = data;
}
}
//往Trie树中插入一个数据
public void insert(char[] data) {
TrieNode node = root;
for(int i=0;i<data.length;i++) {
if(node.children[data[i]-'a']==null) {
node.children[data[i]-'a'] = new TrieNode(data[i]);
}
node = node.children[data[i]-'a'];
}
node.isEndingChar = true;
}
//在Trie树中查找一个数据
public boolean find(char[] data) {
TrieNode node = root;
for(int i=0;i<data.length;i++) {
if(node.children[data[i]-'a']==null) {
return false;//不存在
}
node = node.children[data[i]-'a'];
}
if(node.isEndingChar==false) {
return false;//不是完全匹配
}else {
return true;//完全匹配
}
}
}
public class TestTrieTree {
public static void main(String[] args) {
TrieTree tree = new TrieTree();
//how，hi，her，hello，so，see
tree.insert(new char[] {'h','o','w'});
tree.insert(new char[] {'h','i'});
tree.insert(new char[] {'h','e','r'});
tree.insert(new char[] {'h','e','l','l','o'});
tree.insert(new char[] {'s','o'});
tree.insert(new char[] {'s','e','e'});
System.out.println(tree.find(new char[] {'h','i'}));
System.out.println(tree.find(new char[] {'h','a'}));
}
}
运行结果
true
false
