AC自动机的简单Java实现

AC自动机主要实现多模式字符匹配的快速查找,相关知识点为:

1.trie树

2.KMP算法

代码有相关注释,如下:

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;

import com.git.books.a_lucene_java.aho_corasick.StringSearchResult;

/**
 * <p>Title: MyOneACSearchTest.java</p>
 * <p>Description:ac自动机 </p>
 * <p>Copyright: Copyright (c) 2017</p>
 * <p>Company: Sage</p>
 * @author 五虎将
 * @date 2017年1月5日上午8:19:34
 * @version 1.0
 */
public class MyOneACSearchTest {

    public static void main(String[] args) {
        
        String[] keywords = new String[]{"我是好人","我是坏人","好人","坏人","世界","那么大","世界那么大","大"};
        MyOneACSearchTest search = new MyOneACSearchTest(keywords);
        StringSearchResult[] findAll = search.findAll("我是好人吗?这事需要问问自己,人能分成好人坏人吗?这恐怕谁也无法解答.世界那么大,给你的想法那么大,我们世界里,只能想想大而已");
        for (StringSearchResult result : findAll) {
            System.out.println(result.keyword() + " : " +result.index());
        }
        
    }
    
	//构建树
	//设置失败指针
	//搜索过程

	public MyOneACSearchTest(String[] keywords) {
		buildTree(keywords);
		addFailure();
	}
	private TreeNode root;
	
	//查找全部的模式串
	public StringSearchResult[] findAll(String text){
	    //可以找到 转移到下个节点 不能找到在失败指针节点中查找直到为root节点
	    ArrayList<StringSearchResult> results = new ArrayList<StringSearchResult>();
	    int index = 0;
	    TreeNode mid = root;
	    while(index <text.length()){
	        
	        TreeNode temp = null;
	        
	        while(temp ==null){
	            temp = mid.getSonNode(text.charAt(index));
	            if(mid ==root){
	                break;
	            }
	            if(temp==null){
	                mid = mid.failure;
	            }
	        }
	        //mid为root 再次进入循环 不需要处理  或者 temp不为空找到节点 节点位移
	        if(temp!=null) mid = temp;
	        
	        for (String result : mid.getResults()) {
                results.add(new StringSearchResult(index - result.length() + 1, result));
            }
	        index++;
	    }
	    return results.toArray(new StringSearchResult[results.size()]);
	}
	
	
	private void addFailure() {
		//设置二层失败指针为根节点 收集三层节点
		
		//DFA遍历所有节点 设置失败节点 原则: 节点的失败指针在父节点的失败指针的子节点中查找 最大后缀匹配 
		ArrayList<TreeNode> mid = new ArrayList<TreeNode>();//过程容器
		for (TreeNode node : root.getSonsNode()) {
			node.failure = root;
			for (TreeNode treeNode : node.getSonsNode()) {
				mid.add(treeNode);
			}
		}
		
		//广度遍历所有节点设置失败指针 1.存在失败指针 2.不存在到root结束
		while(mid.size()>0){
			ArrayList<TreeNode> temp = new ArrayList<TreeNode>();//子节点收集器
			
			for (TreeNode node : mid) {
				
				TreeNode r = node.getParent().failure;
				
				while(r!=null && !r.containNode(node.getChar())){
					r = r.failure;//没有找到,保证最大后缀 (最后一个节点字符相同)
				}
				
				//是根结
				if(r==null){
					node.failure = root;
				}else{
					node.failure = r.getSonNode(node.getChar());
					//重叠后缀的包含
					for (String result : node.failure.getResults()) {
                        node.addResult(result);
                    }
				}
				
				//收集子节点
				for (TreeNode treeNode : node.getSonsNode()) {
					temp.add(treeNode);
				}
				
			}
			mid = temp;
		}
		root.failure = root;
	}

	private void buildTree(String[] keywords) {
		root = new TreeNode(null, ' ');
		//判断节点是否存在 存在转移 不存在添加
		for (String word : keywords) {
			TreeNode temp = root;
			for (char ch : word.toCharArray()) {
				if(temp.containNode(ch)){
					temp = temp.getSonNode(ch);
				}else{
					TreeNode newNode = new TreeNode(temp, ch);
					temp.addSonNode(newNode);
					temp = newNode;
				}
			}
			temp.addResult(word);
		}
	}


	class TreeNode{
		
		private TreeNode parent;
		
		private TreeNode failure;
		
		private char ch;
		
		private ArrayList<String> results;
		
		private Hashtable<Character, TreeNode> sonsHash;
		
		private TreeNode[] sonsNode;
		
		
		public TreeNode(TreeNode parent,char ch) {
			
			this.parent = parent;
			this.ch = ch;
			results = new ArrayList<String>();
			sonsHash = new Hashtable<Character,TreeNode>();
			sonsNode = new TreeNode[]{};
		}
		
		//添加子节点
		public void addSonNode(TreeNode node){
			sonsHash.put(node.ch, node);
			sonsNode = new TreeNode[sonsHash.size()];
			Iterator<TreeNode> iterator = sonsHash.values().iterator();
			for (int i = 0; i < sonsNode.length; i++) {
				if(iterator.hasNext()){
					sonsNode[i] = iterator.next();
				}
			}
		}
		
		//获取子节点中指定字符节点
		public TreeNode getSonNode(char ch){
			return sonsHash.get(ch);
		}
		
		//判断子节点中是否存在该字符
		public boolean containNode(char ch){
			return getSonNode(ch) !=null;
		}
		
		//添加一个结果到结果字符中
		public void addResult(String result){
			if(!results.contains(result)) results.add(result);
		}
		
		//获取字符
		public char getChar(){
			return ch;
		}
		
		//获取父节点
	    public TreeNode getParent(){
	    	return parent;
	    }
	    //设置失败指针并且返回
	    public TreeNode setFailure(TreeNode failure){
	    	this.failure = failure;
	    	return this.failure;
	    }
	    
	    //获取所有的孩子节点
	    public TreeNode[] getSonsNode(){
	    	return sonsNode;
	    }
	    //获取搜索的字符串
	    public ArrayList<String> getResults(){
	    	return results;
	    }
	}
}