Trie树

参考：https://blog.csdn.net/johnny901114/article/details/80711441

1.什么是Trie？

Trie又称字典树，单词查找树。它的查找速度主要和字符串长度有关。

Trie字典树主要用于存储字符串，Trie 的每个 Node 保存一个字符。用链表来描述的话，就是一个字符串就是一个链表。每个Node都保存了它的所有子节点。

例如我们往字典树中插入see、pain、paint三个单词，Trie字典树如下所示：

2.特点：

1>共享字符串的公共前缀来节省空间。

2>根节点root不存数据，每一整个分支代表一个字符串。

3>每个分支的内部可能也含有完整的字符串，所以我们可以对于那些是某个字符串结尾的节点做一个标记（isWord=true/false）。

3.实现：

/**
 * 
 */
package trie;

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

/**
 * @author Administrator
 * 
 */
public class Trie {
    private Node root;
    private int size;//单词的个数
    
    private class Node{
        public boolean isWord;
        public Map<Character,Node> next;
        
        public Node(){
            next=new HashMap<>();
        }
        
        public Node(boolean isWord){
            this();
            this.isWord=isWord;
        }
    }
    
    public Trie(){
        root = new Node();
    }
    public int getSize(){//获取
        return size;
    }
    public boolean isEmpty(){
        return size==0;
    }
    /**
     * 往Trie添加一个单词
     * @param word 单词
     */
    public void add(String word){
        Node current=root;
        char[] charArray = word.toCharArray();
        for (char c : charArray) {
            Node next = current.next.get(c);
            if(next==null){
                current.next.put(c, next);
            }
            current=next;
        }
        if(!current.isWord){//如果当前node已经是一个word，则跳过
            size++;
            current.isWord=true;
        }
    }
    /**
     * 判断Trie中是否包含单词
     * @param word
     * @return true/false
     */
    public boolean contains(String word){
        Node current = root;
        char[] charArray = word.toCharArray();
        for (char c : charArray) {
            Node next = current.next.get(c);
            if(next==null){
                return false;
            }
            current=next;
        }
        return current.isWord;
    }
    /**
     * 判断Trie中是否包含前缀
     * @param prefix
     * @return true/false
     */
    public boolean containsPrefix(String prefix){
        Node current = root;
        char[] charArray = prefix.toCharArray();
        for (char c : charArray) {
            Node next = current.next.get(c);
            if(next==null){
                return false;
            }
            current=next;
        }
        return true;
    }
    /**
     * 删除一个单词
     * 1：如果单词的所有字母的都没有多个分支，删除整个单词
     * 2：如果单词是另一个单词的前缀，只需要把该word的最后一个节点的isWord的改成false
     * 3：如果单词的除了最后一个字母，其他的字母有多个分支
     * @param word
     * @return true/false
     */
    public boolean remove(String word){
        Node current = root;
        Node multiChildNode = null;
        int multiChildNodeIndex = -1;
        char[] charArray = word.toCharArray();
        for (int i=0; i<charArray.length; i++) {
            Node child = current.next.get(charArray[i]);
            //如果Trie中不存在该单词
            if(child==null){
                return false;
            }
            //如果当前节点的子节点个数大于1个
            if(child.next.size() >1 ){
                multiChildNode=child;
                multiChildNodeIndex=i;
            }
            current=child;
        }
        //情况1：单词的所有字母都没有多余分支（分支都只有1个），则删除整个单词
        if(multiChildNodeIndex == -1){
            root.next.remove(charArray[0]);
            size--;
            return true;
        }
        //情况2：如果单词后面还有子节点
        if(current.next.size() > 0){
            //如果当前节点的isWord为true
            if(current.isWord){
                current.isWord=false;
                size--;
                return true;
            }
            //否则，不存在该单词，该单词只是前缀
            return false;
        }
        //情况3：如果单词的字母除了最后一个没有分支，其他字母存在分支
        if(multiChildNodeIndex != charArray.length-1){//multiChildNodeIndex == -1 已经做过判断,这里 multiChildNodeIndex!=-1
            multiChildNode.next .remove(charArray[multiChildNodeIndex+1]);
            size--;
            return true;
        }
        return false;
    }
}

4.应用：

1>Trie 最大的特点就是利用了字符串的公共前缀，像我们有时候在百度、谷歌输入某个关键字的时候，它会给我们列举出很多相关的信息

 

这种就是通过Trie实现的。

2>Trie 树来实现敏感词过滤

5.时间复杂度：

如果敏感词的长度为 m，则每个敏感词的查找时间复杂度是 O(m)，字符串的长度为 n，我们需要遍历 n 遍，所以敏感词查找这个过程的时间复杂度是 O(n * m)。

如果有 t 个敏感词的话，构建 trie 树的时间复杂度是 O(t * m)。