package com.dft;
import java.util.*;
/**
* @version V1.0
* @ClassName ACTrie
* @Description 基於字典樹實現AC自動機
* @Author DFT
* @Date 2020/5/20 0020
*/
public class ACTrie {
private boolean failureSetted = false; //是否建立了failure表
private Node root; //根結點
public ACTrie() {
this.root = new Node(true);
}
/**
* @Description 添加一組模式串
* @Author DFT
* @Date 2020/5/24 0024
* @Param [sequences]
* @return void
**/
public void addKeywordList(Collection<? extends CharSequence> sequences){
if (sequences == null || sequences.isEmpty()) return;
for (CharSequence sequence : sequences) {
addKeyword(sequence);
}
}
/**
* @Description 添加一個模式串
* @Author DFT
* @Date 2020/5/24 0024
* @Param [cs]
* @return void
**/
public void addKeyword(CharSequence cs) {
if (cs == null || cs.length() == 0) return;
// 從根節點開始
Node currentState = this.root;
int len = cs.length();
for (int i = 0; i < len; i++) {
// 根據字符添加子節點並返回
currentState = currentState.insert(cs.charAt(i));
}
// 將完整字符串添加到最後一個節點上
currentState.addMatchInfo(cs);
}
/**
* @Description 刪除一個模式串
* @Author DFT
* @Date 2020/5/24 0024
* @Param [cs]
* @return void
**/
public void deleteKeyword(CharSequence cs){
if (cs == null || cs.length() == 0) return;
// 從根節點開始
Node currentState = this.root;
Node parent = this.root;
int count = 0;
int len = cs.length();
for (int i = 0; i < len; i++) {
currentState = currentState.childAt(cs.charAt(i));
if(currentState==null) return;
if(i==len-1) {
if(!currentState.children().isEmpty()) return;
} else if(currentState.children().size()>1 || (currentState.emit()!=null && !currentState.emit().isEmpty())) {
parent = currentState;
count = i + 1;
}
}
parent.map.remove(cs.charAt(count));
}
/**
* @Description 匹配模式串
* @Author DFT
* @Date 2020/5/24 0024
* @Param [text]
* @return java.util.Collection<com.dft.ACTrie.MatchInfo>
**/
public Collection<MatchInfo> search(String text) {
if (!this.failureSetted) setFailNode();
Node currentState = this.root;
List<MatchInfo> matchInfos = new ArrayList<MatchInfo>();
int len = text.length();
for (int position = 0; position < len; position++) {
Character character = text.charAt(position);
currentState = currentState.nextNode(character);
Collection<CharSequence> emits = currentState.emit();
if (emits == null || emits.isEmpty()) {
continue;
}
for (CharSequence emit : emits) {
matchInfos.add(new MatchInfo(position - emit.length() + 1, position, emit));
}
}
return matchInfos;
}
/**
* @Description 判斷是否存在匹配的字符串
* @Author DFT
* @Date 2020/5/24 0024
* @Param [text]
* @return boolean
**/
public boolean findAnyIn(String text){
if (!this.failureSetted) setFailNode();
boolean result = false;
Node currentState = this.root;
int len = text.length();
for (int position = 0; position < len; position++) {
Character c = text.charAt(position);
currentState = currentState.nextNode(c);
Collection<CharSequence> emits = currentState.emit();
if (emits == null || emits.isEmpty()) {
continue;
}
result = true;
}
return result;
}
/**
* @Description 設置失敗節點
* @Author DFT
* @Date 2020/5/24 0024
* @Param []
* @return void
**/
private void setFailNode() {
// 創建一個隊列
Queue<Node> queue = new LinkedList<Node>();
// 1.根節點的所有子節點失敗節點都是根節點
Collection<Node> rootChildren = this.root.children();
for (Node rootChild : rootChildren) {
// 設置失敗節點爲根節點
rootChild.setFailure(this.root);
// 將節點加入隊列用於後續遞歸
queue.add(rootChild);
}
// 使用廣度優先搜索BFS，層次遍歷節點來處理，每一個節點的失敗路徑
while (!queue.isEmpty()) {
// 從隊列中取出一個節點作爲父節點
Node parentNode = queue.poll();
// 獲取該節點的所有子節點
Collection<Node> children = parentNode.children();
for (Node child : children) {
queue.add(child);
// 失敗節點=父節點的失敗節點的next節點
Node failNode = parentNode.getFailure().nextNode(child.value);
child.setFailure(failNode);
child.addMatchInfo(failNode.emit());
}
}
this.failureSetted = true;
}
private static class Node {
private static final char EMPTY = '\0';
private boolean isRoot = false;//是否爲根結點
private Map<Character, Node> map;// 子節點map
private char value;// 節點的值
private Node failure; // 失敗節點
private List<CharSequence> emits; // 輸出
public Node(char value) {
this.value = value;
map = new HashMap<Character, Node>();
emits = new ArrayList<CharSequence>();
}
/**
* @Description 通過帶參數構造器創建根節點
* @Author DFT
* @Date 2020/5/24 0024
* @Param [isRoot]
* @return
**/
public Node(boolean isRoot) {
this(EMPTY);
this.isRoot = isRoot;
}
/**
* @Description 根據字符添加子節點
* @Author DFT
* @Date 2020/5/24 0024
* @Param [character]
* @return com.dft.ACTrie.Node
**/
public Node insert(Character character) {
// 先判斷當前節點中是否包含目標字符的子節點
Node node = this.map.get(character);
if (node == null) {
// 如果沒有 創建一個新的節點
node = new Node(character);
// 添加到當前節點的map中
map.put(character, node);
}
// 返回節點
return node;
}
/**
* @Description 根據給定字符獲取子節點
* @Author DFT
* @Date 2020/5/24 0024
* @Param [character]
* @return com.dft.ACTrie.Node
**/
public Node childAt(Character character) {
return map.get(character);
}
/**
* @Description 根據給定字符跳轉到下一個節點
* @Author DFT
* @Date 2020/5/24 0024
* @Param [transition]
* @return com.dft.ACTrie.Node
**/
private Node nextNode(Character c) {
// 在子節點中獲取next節點
Node next = this.childAt(c);
if (next != null) {
return next;
}
//如果跳轉到根結點還是失敗，則返回根結點
if (this.isRoot) {
return this;
}
// 按失敗節點遞歸
return this.failure.nextNode(c);
}
public void addMatchInfo(CharSequence cs) {
emits.add(cs);
}
public void addMatchInfo(Collection<CharSequence> keywords) {
emits.addAll(keywords);
}
public Collection<Node> children() {
return this.map.values();
}
public void setFailure(Node node) {
failure = node;
}
public Node getFailure() {
return failure;
}
public Collection<CharSequence> emit() {
return this.emits == null ? Collections.<CharSequence>emptyList() : this.emits;
}
}
private static class MatchInfo {
private final CharSequence keyword;// 匹配到的模式串
private final int start;
private final int end;
/**
* 模式匹配結果
*/
public MatchInfo(final int start, final int end, final CharSequence keyword) {
this.start = start;
this.end = end;
this.keyword = keyword;
}
/**
* 獲取模式值
* @return
*/
public CharSequence getKeyword() {
return this.keyword;
}
@Override
public String toString() {
return "MatchInfo{" +
"keyword=" + keyword +
", start=" + start +
", end=" + end +
'}';
}
}
public static void main(String[] args) {
List<String> keywords = Arrays.asList("coxquery#@{","coxquery#@config#@{","coxqueryhealth#@{","agent#@{","agent#@config#@{","agenthealth#@{");
ACTrie trie = new ACTrie();
trie.addKeyword("ctg#@{");
trie.addKeyword("ctg#@config#@{");
trie.addKeyword("ctghealth#@{");
trie.addKeyword("cox#@{");
trie.addKeyword("cox#@config#@{");
trie.addKeyword("coxhealth#@{");
trie.addKeywordList(keywords);
trie.deleteKeyword("coxhealth#@{");
System.out.println(trie.findAnyIn("#@monitor#@dataquery#@coxhealth#@{"));
System.out.println(trie.findAnyIn("#@monitor#@dataquery#@cox#@config#@{"));
Collection<MatchInfo> emits = trie.search("#@monitor#@dataquery#@coxquery#@config#@{");
for (MatchInfo emit : emits) {
System.out.println(emit);
}
}
}
