基于字典树实现AC自动机实现内容关键词检索

已于 2022-05-31 18:31:16 修改
阅读量8.9k 收藏
点赞数 1
分类专栏： java 文章标签： java
于 2021-06-16 15:30:35 首次发布
原文链接：https://blog.csdn.net/yangfu1608/article/details/106314714
版权

 如何使用

private ACTrie ctgACTrie = new ACTrie(); //创建自动机

ctgACTrie.addKeyword("你好"); //丢入关键词

private String passThoughCTG(String name) {
  Collection<MatchInfo> emits = ctgACTrie.search(name);
  if (emits.isEmpty())
    return null;
  MatchInfo m = null;
  for (MatchInfo emit : emits) {
    if (m == null || emit.getEnd()-emit.getStart() > m.getEnd()-m.getStart()) {
      m = emit;
    }
  }
  return m.getKeyword().toString()
}


/*返回 你好*/
passThoughCTG("啊啊啊你好啊啊啊"); //获取这句话有没有关键字

创建自动机类

package com.xdf.udf.util;

import java.util.*;
import lombok.Data;

/**
 * @version V1.0
 * @ClassName ACTrie
 * @Description 基于字典树实现AC自动机
 * @Author DFT
 * @Date 2020/5/20 0020
 * @see "https://blog.csdn.net/qq_44011386/article/details/117958782"
 */
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;
    }
  }

  @Data
  public 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;
    }

  }

  // demo
  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);
    }
  }

}

皮卡帅
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
高效Java敏感词过滤系统AC自动机算法源码，支持独立部署与集成注册中心
03-25
项目简介： 本项目是一款高效的Java敏感词过滤系统，基于AC自动机算法实现。系统支持独立部署，同时可便捷集成至注册中心，为各类项目提供敏感词过滤服务。包含文件共117个，其中主要构成如下： - Java源文件：49个 - Class文件：33个 - 配置XML文件：16个 - 配置YAML文件：5个 - Git忽略配置：2个 - JAR包：2个 - 属性配置文件：2个 - IntelliJ IDEA项目文件：2个 - 列表文件：2个 - Maven命令脚本：1个（SensitiveWords/mvnw） 系统特色功能： - 敏感词组合匹配机制，确保高效过滤； - 独立后台管理，实现敏感词的增删查功能； - 集成主流注册中心，便于服务管理和发现； - 既可作为独立应用部署，也可作为模块嵌入至现有项目中。 该系统旨在为用户提供一个强大、灵活且易于集成的敏感词过滤解决方案，保障信息安全与合规性。
基于关键词的文本排序检索系统
weiambt的博客
06-17 3695
文章目录一、问题描述（一）课题内容（二）课题要求二、需求分析三、TF-IDF模型的实现（1）思路（2）代码实现（2.1）计算TF（2.2）计算IDF（2.3）计算TF-IDF四、主函数的实现五、其他函数的实现（1）文本库加载函数（2）文本库处理函数（2.1）分词及停用词的处理（2.1.1）分词（2.1.2）停用词（2.2）数据处理的主体部分（2.3）dealDataSet()函数的完整源代码（3）导出结果文本函数六、源代码 一、问题描述 （一）课题内容    对于给定文本库（数据集：“题目 B4 的数据集.
关于检索关键字的常用四种方法
qq_42680761的博客
06-06 3505
在前端开发过程中，我们经常会遇到关于检索关键词的问题。遇到这类问题，我们通常会用下面的四个方法来解决检索关键词的问题： 1.检索一个固定的关键词： 　　1.1String.prototype.indexOf()-->indexOf()方法返回指定值在字符串对象中首次出现的位置。从fromIndex位置开始查找，如果不存在，则返回 -1。 语法： str.indexOf(searc...
基于ac自动机实现的敏感词过滤工具类
qq_41577650的博客
08-18 93
【代码】基于ac自动机实现的敏感词过滤工具类。
AC自动机-Java
xuanzui的博客
08-19 1087
AC算法
字典树实现AC自动机
01-03
本文档主要是字典树实现AC自动机用于多模式字符串的匹配算法，包括源代码
Java实现AC自动机全文检索示例
08-31
本篇文章主要介绍了Java实现AC自动机全文检索示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
java编程之AC自动机工作原理与实现代码
08-28
主要介绍了java编程之AC自动机的有关内容，涉及其应用场景，运行原理，运行过程，构造方法及Java中的实现代码，具有一定参考价值，需要的朋友可以了解下。
基于Matlab实现元胞自动机（CA）.rar
最新发布
09-22
1、资源内容：基于Matlab实现元胞自动机（CA）.rar 2、适用人群：计算机，电子信息工程、数学等专业的学习者，作为自己程序部分功能的“参考资料”使用。 3、解压说明：本资源需要电脑端使用WinRAR、7zip等解压工具...
基于python实现元细胞自动机
08-16
展示链接：https://www.bilibili.com/video/BV1uV4y1s7qt
Trie 与 AC自动机
KaiserWilheim的博客
04-29 327
Trie树（字典树）与AC自动机。
基于中文AC自动机--实现中文文本中特定参数的抽取
qq_36676123的博客
11-13 714
近来需要做一些从中文文本中提取关键字（关键字自定义）的操作，偶然间了解了AC自动机算法，而网上的算法大多是基于英文实现的，所以也只是适用于英文提取关键字，因此最近研究了一下中文AC自动机的实现，记录下自己的思路，以期与大家共勉。 关于AC自动机，网上也已经是有了许多非常详细的介绍，比较关键的两步就是trie树和fail指针的构建，在这里也不再赘述，不清楚的可以去https://bestsort.cn/2019/04/28/402/。下面综合代码讲解一下我个人的实现方法，我使用java语言实现。 首先呢，
Python——利用AC自动机进行关键词提取
GeekZW的博客
02-26 8043
Python——AC自动机 目标：在之前写的文章【Python实现多模匹配——AC自动机】基础上，安装gcc（C编译器），再装ahocorasick ，并完成从文本中提取关键词的任务。由于原理之前已经介绍，这里只介绍安装过程与例子。 1、安装ahocoras...
利用AC自动机进行关键字的提取和过滤
黑暗之神
02-01 2999
昨天看了meituan.com的AC算法在美团上单系统的应用一文，深受启发，原来ACM算法在工程中也能有这样赤裸裸的运用~~~ 于是便复习了AC自动机，并把代码用java重新搞了一遍~~ AC自动机整体的结果大概是长这样的，其实就是在trie树上做KMP ： AC自动机里面比较难理解的应该是它的失配指针的计算过程。 这个计算过程从本质上讲就是进
python txt文本特定字符串提取
测试人的成长日志
06-23 4494
方法一：思路：将txt文件读成一个字符串，在整个字符串中进行匹配，匹配到的是数组，再从数组的对应位置取数据txt样例：------begin checkaccuracy--------- Validating batch 10 Validating batch 20 Validating batch 30 Validating batch 40 Validating batch 50 Validating batch 60 Total Top1 Accuracy: 70.40% Total To
ac算法 java_java使用ac算法实现关键词高亮
weixin_34646207的博客
02-12 245
需求背景标记出一句话中所有关键词inpu:我想买苹果手机，请问哪里可以买苹果手机keyword:"苹果", "苹果手机", "哪里"result:我想买[[苹果手机]]，请问[[哪里]]可以买[[苹果手机]]10w条耗时：41ms难点：需要考虑单词重叠问题(overlap)，例如“苹果手机”同时包含两个关键词，只标记一次。思路通过ac自动机遍历得到所有关键词；新建一个byte[]，长度等于原句子，...
AC自动机——搜索关键词+单词
测试
10-21 409
构建next数组过程，首先看回kmp算法里面的next数组的构建过程，在下图里面的j代表的具体意义实际上是next[i-1]，也就是第i-1个字符与前缀的最大匹配长度，下面的while循环里面a[i]和a[j+1]的比较实际上就是第i个字符和第i-1个字符能够匹配上的最大长度的前缀的下一个进行比较，如果相同就能让第i个字符的next[i]==next[i-1]+1；ac自动机里面的next数组存的是以当前字母结尾的字符串与从开头开始的字符串的最大匹配长度的字符串的指针。思路：没想好，不写先。
AC自动机
yuanyuneixin1的专栏
04-02 339
如果你想在一篇文章快速的查询含有的所有关键字，可以考虑AC自动机。
java ac自动机_ac自动机java版
weixin_35952929的博客
02-23 310
【实例简介】从别的共享资源下载的java版ac自动机，已验证使用非常好。【实例截图】【核心代码】ahocorasick_java-1.1└── ahocorasick_java-1.1├── ahocorasick│ ├── pom.xml│ ├── src│ │ └── main│ │ └── java│ │ └── org│ │ ...
用java代码写双数组字典树实现的AC自动机
07-08
下面是使用Java代码实现双数组字典树（Double Array Trie）的AC自动机： ```java import java.util.*; class ACNode { public int[] children; // 子节点指针 public int parent; // 父节点指针 public boolean isWordEnd; // 是否是单词结尾 public char character; // 字符 public int failureLink; // 失败指针 public List<Integer> output; // 输出 public ACNode(int parent, char character) { children = new int[26]; Arrays.fill(children, -1); this.parent = parent; this.character = character; isWordEnd = false; failureLink = -1; output = new ArrayList<>(); } } class ACTrie { private List<ACNode> trie; public ACTrie() { trie = new ArrayList<>(); trie.add(new ACNode(-1, (char) 0)); } public void insert(String word) { int node = 0; for (char c : word.toCharArray()) { int index = c - 'a'; if (trie.get(node).children[index] == -1) { trie.add(new ACNode(node, c)); trie.get(node).children[index] = trie.size() - 1; } node = trie.get(node).children[index]; } trie.get(node).isWordEnd = true; } public void buildFailureLinks() { Queue<Integer> queue = new LinkedList<>(); // 根节点的失败指针为根节点本身 trie.get(0).failureLink = 0; // 初始化第一层节点的失败指针为根节点 for (int child : trie.get(0).children) { if (child != -1) { trie.get(child).failureLink = 0; queue.add(child); } } // 广度优先遍历构建失败指针 while (!queue.isEmpty()) { int currentNode = queue.poll(); for (int i = 0; i < 26; i++) { int child = trie.get(currentNode).children[i]; if (child != -1) { queue.add(child); int failure = trie.get(currentNode).failureLink; while (trie.get(failure).children[i] == -1 && failure != 0) { failure = trie.get(failure).failureLink; } if (trie.get(failure).children[i] != -1) { failure = trie.get(failure).children[i]; } trie.get(child).failureLink = failure; // 将失败节点的输出添加到当前节点的输出中 trie.get(child).output.addAll(trie.get(failure).output); } } } } public List<Integer> search(String text) { List<Integer> result = new ArrayList<>(); int node = 0; for (int i = 0; i < text.length(); i++) { char c = text.charAt(i); int index = c - 'a'; while (trie.get(node).children[index] == -1 && node != 0) { node = trie.get(node).failureLink; } if (trie.get(node).children[index] != -1) { node = trie.get(node).children[index]; } result.addAll(trie.get(node).output); if (trie.get(node).isWordEnd) { result.add(i); } } return result; } } public class Main { public static void main(String[] args) { ACTrie acTrie = new ACTrie(); // 添加模式串 acTrie.insert("he"); acTrie.insert("she"); acTrie.insert("his"); acTrie.insert("hers"); // 构建失败指针 acTrie.buildFailureLinks(); // 搜索文本 String text = "ushers"; List<Integer> result = acTrie.search(text); // 输出匹配位置 for (int position : result) { System.out.println("Pattern found at index: " + (position - text.length() + 1)); } } } ``` 此代码实现了双数组字典树（Double Array Trie）的AC自动机，用于在给定文本中搜索多个模式串的出现位置。在示例代码中，我们添加了模式串"he"、"she"、"his"和"hers"，并搜索文本"ushers"，输出匹配的位置。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值