AC多模式匹配算法

文章大约分为以下3个部分:

1、应用背景;

2、AC算法介绍及其原理;

3、AC算法的Java实现;

 

1、应用背景

在互联网应用中,通常会用到关键词检测功能,以防止用户发表包括了指定关键词的内容。如游戏的聊天系统、角色名称检测,论坛发帖、直播弹幕等,都需要对用户发布的内容进行检测,以检测是否包含敏感的关键字。

 

通常需要检测的关键词,会有很多很多,比如侮辱人的关键词,政治敏感的关键词,系统相关的特定关键词等。毫不夸张的说,通常要检测的关键词会有几千个,甚至过万。这时效率都变得尤为突出,如果检测关键词的效率低下,对大型互联网应用来说,很可能有是致命的。

 

8000个关键词为例,如果使用正则表达式,则需要对用户发布的内容遍历8000遍。如果同一秒中,有100位,1000位,10000位...用户发布内容,可想而知仅仅在关键词检测方面服务器上CPU的开销。

 

AC多模式匹配算法,可以有效的解决关键词检测的效率问题。时间复杂度为O(n),n为用户发布内容的长度n。基本与关键词的数量无关。

 

2、AC算法介绍及其原理

AC算法是Alfred V.Aho(《编译原理》的作者),和Margaret J.Corasick于1974年提出(与KMP算法同年)的一个经典的多模式匹配算法,可以保证对于给定的长度为n的文本,和模式集合P{p1,p2,...pm},在O(n)时间复杂度内,找到文本中的所有目标模式,而与模式集合的规模m无关。

 

AC算法实现原理,大体上可分为三步:
1)、构建敏感词树型结构,并标注结束节点(即是否是一个敏感词的结束);
2)、为树上的结点,构建匹配失败时的跳转-失败结点(即匹配失败时,跳转到哪个结点继续匹配);
3)、对用户内容进行一次遍历,对于每个字符(字节)都去敏感词树型结构中,从当前结点位置开始匹配。
如果匹配成功,则当前结点,下移到对应的结点。如果当前结点为“结束节点”,则表示匹配成功;
如果匹配失败,则当前结点,跳转到该结点的失败结点,继续匹配,直到匹配成功或当前结点为根结点;

 

1)构建敏感词树型结构,并标注结束节点(即是否是一个敏感词的结束)
首先要有一个根结点;
遍历所有的敏感词,将每个敏感词的每一个字节,放到树上,成为一个结点。每一个字节的前一字节所对应的结点,都为该字节所对应结点的父结点。如果字节所对应的结点已存在,则不再添加新的结点。如果该字节为敏感词的最后一个字节,则将对应结点,设置为结束结点。

如敏感词:he,hers,his,erase


AC多模式匹配算法_第1张图片
 

 

2)为树上的结点,构建匹配失败时的跳转-失败结点(即匹配失败时,跳转到哪个结点继续匹配)
第一层子节点的失败节点,直接指定是根结点;
其它子节点的失败节点,是其父结点的失败点中查找相应的路径。如果查不到,则继续在当前结点的失败结点中查找相应的路径。直到找相应的节点,或失败节点为根结点。


AC多模式匹配算法_第2张图片
 

 

3)对用户内容进行一次遍历,对于每个字符(字节)都去敏感词树型结构中,从当前结点位置开始匹配。
如果匹配成功,则当前结点,下移到对应的结点。如果当前结点为“结束节点”,则表示匹配成功;
如果匹配失败,则当前结点,跳转到该结点的失败结点,继续匹配,直到匹配成功或当前结点为根结点;

以herase为类,演示

AC多模式匹配算法_第3张图片
 

3、AC算法的Java实现

数据结构,关键词树上的结点Node.java

package cn.buddie.ac.model;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
 * 结点类
 * 
 * @author buddie
 *
 */
public class Node {
	// 当前结点的层级
	private int level;
	// 当前结点后子结点,Key为小写字母
	private Map subNodes;
	// 当前结果匹配失败时的跳转结点
	private Node failNode;
	// 当前结点是否是终结结点
	private boolean terminal;

	/**
	 * 当前结点是否已包含指定Key值的子结点
	 * 
	 * @param c
	 * @return
	 */
	public boolean containSubNode(Character c) {
		if (this.subNodes == null || this.subNodes.isEmpty()) {
			return false;
		}
		return subNodes.containsKey(c);
	}

	/**
	 * 获取指定Key值的子结点
	 * 
	 * @param c
	 * @return
	 */
	public Node getSubNode(Character c) {
		if (this.subNodes == null || this.subNodes.isEmpty()) {
			return null;
		}
		return subNodes.get(c);
	}

	/**
	 * 添加子结点
	 * 
	 * @param c
	 * @param node
	 */
	public void addSubNode(Character c, Node node) {
		if (this.subNodes == null) {
			this.subNodes = new HashMap();
		}
		this.subNodes.put(c, node);
	}

	// getter & setter
	public int getLevel() {
		return level;
	}

	public void setLevel(int level) {
		this.level = level;
	}

	public Map getSubNodes() {
		return subNodes == null ? Collections.emptyMap() : subNodes;
	}

	public void setSubNodes(Map subNodes) {
		this.subNodes = subNodes;
	}

	public Node getFailNode() {
		return failNode;
	}

	public void setFailNode(Node failNode) {
		this.failNode = failNode;
	}

	public boolean isTerminal() {
		return terminal;
	}

	public void setTerminal(boolean terminal) {
		this.terminal = terminal;
	}

}

 

构建关键词树,关构建失败结点

package cn.buddie.ac.tree;

import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Set;

import cn.buddie.ac.model.Node;

public class ACTree {
	private Node rootNode;

	public ACTree(String[] keyWords) {
		// 初始树
		initTree(keyWords);
		// 构建失败跳转
		buildFailLink();
	}

	/**
	 * 初始树
	 * 
	 * @param keyWords
	 */
	private void initTree(String[] keyWords) {
		rootNode = new Node();
		rootNode.setSubNodes(new HashMap());
		char[] charArray;
		for (String keyWord : keyWords) {
			if (keyWord.isEmpty()) {
				continue;
			}
			charArray = keyWord.toLowerCase().toCharArray();
			buildKeyMap(charArray);
		}
	}

	/**
	 * 构建指定字符数组的结点
	 * 
	 * @param charArray
	 */
	private void buildKeyMap(char[] charArray) {
		Character c;
		Node curNode = rootNode;
		Node node;
		for (int i = 0; i < charArray.length; i++) {
			c = charArray[i];
			if (curNode.containSubNode(c)) {
				node = curNode.getSubNode(c);
			} else {
				node = new Node();
				node.setLevel(i + 1);
				curNode.addSubNode(c, node);
			}
			if (i == charArray.length - 1) {
				node.setTerminal(true);
			}
			curNode = node;
		}
	}

	/**
	 * 构建失败跳转
	 */
	private void buildFailLink() {
		buildFirstLevelFailLink();
		buildOtherLevelFailLink();
	}

	/**
	 * 根结点的所有第一级子结点,失败跳转均为根结点
	 */
	private void buildFirstLevelFailLink() {
		Collection nodes = rootNode.getSubNodes().values();
		for (Node node : nodes) {
			node.setFailNode(rootNode);
		}
	}

	/**
	 * 根结点、第一级结点以外的所有结点,失败跳转均为其父结点的失败结点的对应子结点
	 */
	private void buildOtherLevelFailLink() {
		Queue queue = new LinkedList(rootNode.getSubNodes().values());
		Node node;
		while (!queue.isEmpty()) {
			node = queue.remove();
			buildNodeFailLink(node, queue);
		}
	}

	/**
	 * 构建指定结点的下一层结点的失败跳转
	 * 
	 * @param node
	 */
	private void buildNodeFailLink(Node node, Queue queue) {
		if (node.getSubNodes().isEmpty()) {
			return;
		}
		queue.addAll(node.getSubNodes().values());
		Node failNode = node.getFailNode();
		Set subNodeKeys = node.getSubNodes().keySet();
		Node subFailNode;
		for (Character key : subNodeKeys) {
			subFailNode = failNode;
			while (subFailNode != rootNode && !subFailNode.containSubNode(key)) {
				subFailNode = subFailNode.getFailNode();
			}
			subFailNode = subFailNode.getSubNode(key);
			if (subFailNode == null) {
				subFailNode = rootNode;
			}
			node.getSubNode(key).setFailNode(subFailNode);
		}
	}

	// getter
	public Node getRootNode() {
		return rootNode;
	}
}

 

过滤、替换工具类

package cn.buddie.ac.filter;

import org.apache.commons.lang.StringUtils;

import cn.buddie.ac.model.Node;
import cn.buddie.ac.tree.ACTree;

public class ACFilter {
	public static final Character REPLACE_CHAR = '*';

	private ACTree tree;

	public ACFilter(ACTree tree) {
		this.tree = tree;
	}

	/**
	 * 过滤
	 * 
	 * @param word
	 * @return
	 */
	public String filter(String word) {
		if (StringUtils.isEmpty(word)) {
			return "";
		}
		char[] words = word.toLowerCase().toCharArray();
		char[] result = null;
		Node curNode = tree.getRootNode();
		Node subNode;
		Character c;
		int fromPos = 0;
		for (int i = 0; i < words.length; i++) {
			c = words[i];
			subNode = curNode.getSubNode(c);
			while (subNode == null && curNode != tree.getRootNode()) {
				curNode = curNode.getFailNode();
				subNode = curNode.getSubNode(c);
			}
			if (subNode != null) {
				curNode = subNode;
			}
			if (curNode.isTerminal()) {
				int pos = i - curNode.getLevel() + 1;
				if (pos < fromPos) {
					pos = fromPos;
				}
				if (result == null) {
					result = word.toLowerCase().toCharArray();
				}
				for (; pos <= i; pos++) {
					result[pos] = REPLACE_CHAR;
				}
				fromPos = i + 1;
			}
		}
		if (result == null) {
			return word;
		}
		return String.valueOf(result);
	}

}

 

 

Demo

package cn.buddie.ac;

import cn.buddie.ac.filter.ACFilter;
import cn.buddie.ac.tree.ACTree;

public class WordFilterTest {

	public static void main(String[] args) {
		String[] keyWords = new String[] { "he", "hers", "his", "erase" };
		ACTree tree = new ACTree(keyWords);
		ACFilter filter = new ACFilter(tree);
		String str = "herase";
		str = filter.filter(str);
		System.out.println(str);
	}
}

 

你可能感兴趣的:(算法,Java)