多模字符串匹配算法原理及Java实现代码

多模字符串匹配算法在这里指的是在一个字符串中寻找多个模式字符字串的问题。一般来说，给出一个长字符串和很多短模式字符串，如何最快最省的求出哪些模式字符串出现在长字符串中是我们所要思考的。该算法广泛应用于关键字过滤、入侵检测、病毒检测、分词等等问题中。多模问题一般有trie树，ac算法，wm算法等等。

背景

在做实际工作中，最简单也最常用的一种自然语言处理方法就是关键词匹配，例如我们要对n条文本进行过滤，那本身是一个过滤词表的，通常进行过滤的代码如下

for (string document : documents) {
 for (string filterword : filterwords) {
  if (document.contains(filterword)) {
   //process ...
  }
 }
}

如果文本的数量是n，过滤词的数量是k，那么复杂度为o(nk)；如果关键词的数量较多，那么支行效率是非常低的。

计算机科学中，aho–corasick算法是由alfredv.aho和margaretj.corasick发明的字符串搜索算法，用于在输入的一串字符串中匹配有限组“字典”中的子串。它与普通字符串匹配的不同点在于同时与所有字典串进行匹配。算法均摊情况下具有近似于线性的时间复杂度，约为字符串的长度加所有匹配的数量。然而由于需要找到所有匹配数，如果每个子串互相匹配（如字典为a，aa，aaa，aaaa，输入的字符串为aaaa），算法的时间复杂度会近似于匹配的二次函数。

原理

在一般的情况下，针对一个文本进行关键词匹配，在匹配的过程中要与每个关键词一一进行计算。也就是说，每与一个关键词进行匹配，都要重新从文档的开始到结束进行扫描。ac自动机的思想是，在开始时先通过词表，对以下三种情况进行缓存：

按照字符转移成功进行跳转（success表）

按照字符转移失败进行跳转（fail表）

匹配成功输出表（output表）

因此在匹配的过程中，无需从新从文档的开始进行匹配，而是通过缓存直接进行跳转，从而实现近似于线性的时间复杂度。

构建

构建的过程分三个步骤，分别对success表，fail表，output表进行构建。其中output表在构建sucess和fail表进行都进行了补充。fail表是一对一的，output表是一对多的。

按照字符转移成功进行跳转（success表）

sucess表实际就是一棵trie树，构建的方式和trie树是一样的，这里就不赘述。

按照字符转移失败进行跳转（fail表）

设这个节点上的字母为c，沿着他父亲的失败指针走，直到走到一个节点，他的儿子中也有字母为c的节点。然后把当前节点的失败指针指向那个字母也为c的儿子。如果一直走到了root都没找到，那就把失败指针指向root。使用广度优先搜索bfs，层次遍历节点来处理，每一个节点的失败路径。

匹配成功输出表（output表）

匹配

举例说明，按顺序先后添加关键词he，she，,his，hers。在匹配ushers过程中。先构建三个表，如下图，实线是sucess表，虚线是fail表，结点后的单词是ourput表。

代码

import java.util.*;
/**
 */
public class actrie {
    private boolean failurestatesconstructed = false;
    //是否建立了failure表
    private node root;
    //根结点
    public actrie() {
        this.root = new node(true);
    }
    /**
  * 添加一个模式串
  * @param keyword
  */
    public void addkeyword(string keyword) {
        if (keyword == null || keyword.length() == 0) {
            return;
        }
        node currentstate = this.root;
        for (character character : keyword.tochararray()) {
            currentstate = currentstate.insert(character);
        }
        currentstate.addemit(keyword);
    }
    /**
  * 模式匹配
  *
  * @param text 待匹配的文本
  * @return 匹配到的模式串
  */
    public collection<emit> parsetext(string text) {
        checkforconstructedfailurestates();
        node currentstate = this.root;
        list<emit> collectedemits = new arraylist<>();
        for (int position = 0; position < text.length(); position++) {
            character character = text.charat(position);
            currentstate = currentstate.nextstate(character);
            collection<string> emits = currentstate.emit();
            if (emits == null || emits.isempty()) {
                continue;
            }
            for (string emit : emits) {
                collectedemits.add(new emit(position - emit.length() + 1, position, emit));
            }
        }
        return collectedemits;
    }
    /**
  * 检查是否建立了failure表
  */
    private void checkforconstructedfailurestates() {
        if (!this.failurestatesconstructed) {
            constructfailurestates();
        }
    }
    /**
  * 建立failure表
  */
    private void constructfailurestates() {
        queue<node> queue = new linkedlist<>();
        // 第一步，将深度为1的节点的failure设为根节点
        //特殊处理：第二层要特殊处理，将这层中的节点的失败路径直接指向父节点(也就是根节点)。
        for (node depthonestate : this.root.children()) {
            depthonestate.setfailure(this.root);
            queue.add(depthonestate);
        }
        this.failurestatesconstructed = true;
        // 第二步，为深度 > 1 的节点建立failure表，这是一个bfs 广度优先遍历
        /**
   * 构造失败指针的过程概括起来就一句话：设这个节点上的字母为c，沿着他父亲的失败指针走，直到走到一个节点，他的儿子中也有字母为c的节点。
   * 然后把当前节点的失败指针指向那个字母也为c的儿子。如果一直走到了root都没找到，那就把失败指针指向root。
   * 使用广度优先搜索bfs，层次遍历节点来处理，每一个节点的失败路径。
   */
        while (!queue.isempty()) {
            node parentnode = queue.poll();
            for (character transition : parentnode.gettransitions()) {
                node childnode = parentnode.find(transition);
                queue.add(childnode);
                node failnode = parentnode.getfailure().nextstate(transition);
                childnode.setfailure(failnode);
                childnode.addemit(failnode.emit());
            }
        }
    }
    private static class node{
        private map<character, node> map;
        private list<string> emits;
        //输出
        private node failure;
        //失败中转
        private boolean isroot = false;
        //是否为根结点
        public node(){
            map = new hashmap<>();
            emits = new arraylist<>();
        }
        public node(boolean isroot) {
            this();
            this.isroot = isroot;
        }
        public node insert(character character) {
            node node = this.map.get(character);
            if (node == null) {
                node = new node();
                map.put(character, node);
            }
            return node;
        }
        public void addemit(string keyword) {
            emits.add(keyword);
        }
        public void addemit(collection<string> keywords) {
            emits.addall(keywords);
        }
        /**
   * success跳转
   * @param character
   * @return
   */
        public node find(character character) {
            return map.get(character);
        }
        /**
   * 跳转到下一个状态
   * @param transition 接受字符
   * @return 跳转结果
   */
        private node nextstate(character transition) {
            node state = this.find(transition);
            // 先按success跳转
            if (state != null) {
                return state;
            }
            //如果跳转到根结点还是失败，则返回根结点
            if (this.isroot) {
                return this;
            }
            // 跳转失败的话，按failure跳转
            return this.failure.nextstate(transition);
        }
        public collection<node> children() {
            return this.map.values();
        }
        public void setfailure(node node) {
            failure = node;
        }
        public node getfailure() {
            return failure;
        }
        public set<character> gettransitions() {
            return map.keyset();
        }
        public collection<string> emit() {
            return this.emits == null ? collections.<string>emptylist() : this.emits;
        }
    }
    private static class emit{
        private final string keyword;
        //匹配到的模式串
        private final int start;
        private final int end;
        /**
   * 构造一个模式串匹配结果
   * @param start 起点
   * @param end  重点
   * @param keyword 模式串
   */
        public emit(final int start, final int end, final string keyword) {
            this.start = start;
            this.end = end;
            this.keyword = keyword;
        }
        /**
   * 获取对应的模式串
   * @return 模式串
   */
        public string getkeyword() {
            return this.keyword;
        }
        @override
          public string tostring() {
            return super.tostring() + "=" + this.keyword;
        }
    }
    public static void main(string[] args) {
        actrie trie = new actrie();
        trie.addkeyword("hers");
        trie.addkeyword("his");
        trie.addkeyword("she");
        trie.addkeyword("he");
        collection<emit> emits = trie.parsetext("ushers");
        for (emit emit : emits) {
            system.out.println(emit.start + " " + emit.end + "\t" + emit.getkeyword());
        }
    }
}

总结

以上就是本文关于多模字符串匹配算法原理及java实现代码的全部内容，希望对大家有所帮助。如有不足之处，欢迎留言指出。感谢朋友们对本站的支持。

原文链接：https://www.cnblogs.com/hwyang/p/6836438.html