多模式匹配算法-AC算法

模式匹配，一般分为单模式匹配和多模式匹配。当然，一般都用于字符序列的匹配当中。

多模式匹配，一般是指在一个较长的字符序列中，有多个模式串要进行匹配。

本文展示的是多模式匹配算法中一款较为经典的算法--AC算法。

AC 算法的核心思想是构造词典的自动机(可以使用trie树来实现)， 其算法复杂度是O(m+k+z), m是文本长度，k是所有pattern长度之和，z是字符串中出现pattern的个数。

在普通的算法里面，每个模式串都要回退，子串也要跟着回退，这样算法复杂度是O(m*k*n),m是文本长度，k是所有pattern的总长度，n是pattern的个数。

AC算法，通过逐个解析所有的模式串，生成一个字典树，来避免回溯问题。

计算机学的好的同学，一定知道有限状态自动机这个名词，其实，解析所有模式串就是为了生成这东西，不知道的同学，也无所谓啦，只要理解算法，完事OK。

对照图片中的树，搞定三个功能的方法，算法就实现了。图中的模式串为：{"he","she","his","hers"}

通过这幅图，我们可以看到，树的根state为0，依次根据模式串，生成这棵树。

三个方法分别是：go方法、failure方法和output方法。go方法是实现图中，实线箭头功能的，输入当前节点的数字（其实是自动机的状态）和箭头上的字符时，返回下一个节点；failure方法是实现图中，虚线箭头功能的，当go方法输入参数没有对应节点时，可以沿着虚线的箭头走，匹配过程得以继续；output方法是实现图中花括号的功能，也就是说，当匹配成功时，输入节点数字，可以得到当前匹配的模式串。

通俗的讲，三个方法，go用来对字符进行匹配，失配的情况下走failure路线，匹配成功了就调用output输出。

理解了算法的意思，实现起来就方便了，你可以针对上述三个方法，生成对应的三个数据，分别完成三个方法的功能。

我的实现方案中，把三个方面的数据都糅合到一棵树里面了，也不知道好看懂不。

package houlei.support.matcher;

/**
 * 多模式匹配算法（AC算法）的匹配器。匹配字符串。
 * <p>
 * 创建时间： 2012-7-22 上午02:00:44
 * </p>
 * @author 侯磊
 * @since 1.0
 * @version 1.0
 */
public class ACStringMatcher {

	/**
	 * 当模式串匹配成功时，回调该接口方法。
	 */
	public interface StringHandler{
		void onMatch(int index,String str,String pattern);
	}

	/** 树的节点 */
	static class Node{
		int state;//节点数字；自动机的状态.
		char character=0;//指向当前节点的字符，注意是被指向的
		String patterns[];//匹配成功时，当前节点对于的模式串
		Node[] children;//当前节点的子节点
		Node failureNode=this;//失配路线中的下一个节点
		
		public Node() {
		}

		public Node(int state, char character, Node failureNode) {
			super();
			this.state = state;
			this.character = character;
			this.failureNode = failureNode;
		}

		public boolean containsChildCharacter(char c){
			if(children!=null){
				for(Node node : children){
					if(node.character == c){
						return true;
					}
				}
			}
			return false;
		}
		
        public Node getChild(char c){
        	if(children!=null){
				for(Node node : children){
					if(node.character == c){
						return node;
					}
				}
			}
			return null;
        }
        
        public void addChild(Node node){
        	if(children==null){
        		children=new Node[]{node};
        	}else{
        		Node[] childs = new Node[children.length+1];
        		System.arraycopy(children, 0, childs, 0, children.length);
        		childs[children.length] = node;
        		children = childs;
        	}
        }
        
        public void addPattern(String pattern){
        	if(patterns==null){
        		patterns=new String[]{pattern};
        	}else{
        		String[] newPatterns = new String[patterns.length+1];
        		System.arraycopy(patterns, 0, newPatterns, 0, patterns.length);
        		newPatterns[patterns.length] = pattern;
        		patterns = newPatterns;
        	}
        }
	}
	
	/**
	 * 待匹配的模式串
	 */
	public static class Patterns{
		/** table的默认容量 */
		static final int DEFAULT_INITIAL_CAPACITY = 32;
		/** table的默认增量 */
		static final int DEFAULT_INCREAMENT = 32;
		/** 树的根节点 */
		protected final Node root = new Node();
		/** 辅助创建树的数组 */
		protected Node[] table;
		protected int tableSize;//table的大小，实际使用量。
		protected String[] patterns;//所有的模式串
		
		public Patterns(String[] patterns) {
			this.patterns = patterns;
			table = new Node[DEFAULT_INITIAL_CAPACITY];
			table[0] = root;
			tableSize = 1;
			for(String pattern:patterns){
				addPattern(pattern);
			}
		}
		
		public Patterns() {
			this(new String[0]);
		}
		
		protected void tableAdd(Node node){
			if(table.length<tableSize+1){
				Node[] nodes = new Node[table.length+DEFAULT_INCREAMENT];
				System.arraycopy(table, 0, nodes, 0, tableSize);
				table = nodes;
			}
			table[tableSize++] = node;
		}
		/**
		 * 添加一个模式串。每添加一个模式串，都会对字典树进行更新。
		 * @param pattern 添加的模式串
		 */
		public void addPattern(String pattern) {
			char[] chs = pattern.toCharArray();
			Node current = root;
			for(int i=0;i<chs.length;i++){
				if(current.containsChildCharacter(chs[i])){
					current = current.getChild(chs[i]);
				}else{
					Node node = new Node(tableSize,chs[i],root);
					current.addChild(node);
					current = node;
					tableAdd(node);
					/** 生成失配的路线数据 */
					for(int k=1;k<tableSize-1;k++){
						if(table[k].character==chs[i]){
							current.failureNode = table[k];
							break;
						}
					}
				}
			}
			current.addPattern(pattern);
			/** 生成相同后缀的模式串信息 */
			for(int k=1;k<tableSize-1;k++){
				if(table[k].patterns!=null){
					for(String suffix : table[k].patterns){
						if(pattern.endsWith(suffix)){
							current.addPattern(suffix);
						}
					}
				}
			}
		}

		public final Node getRoot() {
			return root;
		}
		
	}
	
	private final Patterns patterns;
	
	public ACStringMatcher(String[] patterns) {
		this.patterns = new Patterns(patterns);
	}
	
	public ACStringMatcher(Patterns patterns) {
		this.patterns = patterns;
	}
	
	/**
	 * 字符串的匹配。当模式串匹配成功时，回调{@link StringHandler#onMatch(int, String, String)}接口方法。
	 * @param data 待匹配的数据
	 * @param pattern 模式串
	 * @param handler 处理器对象
	 */
	public void match(String data, StringHandler handler) {
		Node node = patterns.getRoot();
		char[] chs = data.toCharArray();
		for(int i=0;i<chs.length;i++){
			if(node.containsChildCharacter(chs[i])){
				node = node.getChild(chs[i]);
				if(node.patterns!=null){
					for(String pattern : node.patterns){
						handler.onMatch(i-pattern.length()+1, data, pattern);
					}
				}
			}else{
				node = node.failureNode;
			}
		}
	}
	
	public final Patterns getPatterns() {
		return patterns;
	}
}

算法的代码还有优化的余地，不过，先实现了算法再说吧。