[java] Trie前缀树

定义

又称单词查找树，字典树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。

这是一颗存储了see, pain, pand和dog四个单词的前缀树

如果不考虑字母的大小写，那么Trie字典树的每个节点都可能有26个子节点。

Trie的常用操作（构造、查找单词和查找前缀）

删除操作用的较少，我就不写了

构造时每个节点都要加上一个is_word属性，用于判断是否为单词。如文章开头的定义图，这棵树里面已经有pand这个单词了，如果用户去查询pan这个单词返回的是false，所以要给每个单词的结尾设置一个is_word属性，如果n的is_word为true，那么就说明树里面包含了pan单词。

代码如下：

public class Trie {
    private boolean is_word=false;
    private Trie next[]=new Trie[26];

    public Trie(){}

    public void insert(String word){//插入单词
        Trie root=this;
        for(char w:word.toCharArray()){
            if(root.next[w-'a']==null)root.next[w-'a']=new Trie();
            root=root.next[w-'a'];
        }
        root.is_word=true;
    }

    public boolean search(String word){//查找单词
        Trie root=this;
        for(char w:word.toCharArray()){
            if(root.next[w-'a']==null)return false;
            root=root.next[w-'a'];
        }
        return root.is_word;
    }
    
    public boolean startsWith(String prefix){//查找前缀
        Trie root=this;
        for(char w:prefix.toCharArray()){
            if(root.next[w-'a']==null)return false;
            root=root.next[w-'a'];
        }
        return true;
    }
}

应用

事实上Trie树在日常生活中的使用随处可见。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。 Trie的核心思想是空间换时间，适用于大规模的数据。

1、前缀匹配

例如：找出一个字符串集合中所有以 五分钟 开头的字符串。我们只需要用所有字符串构造一个 trie树，然后输出以 五−>分−>钟 开头的路径上的关键字即可。 trie树前缀匹配常用于搜索提示。如当输入一个网址，可以自动搜索出可能的选择。当没有完全匹配的搜索结果，可以返回前缀最相似的可能

2、字符串检索

给出 N 个单词组成的熟词表，以及一篇全用小写英文书写的文章，按最早出现的顺序写出所有不在熟词表中的生词。 检索/查询功能是Trie树最原始的功能。给定一组字符串，查找某个字符串是否出现过，思路就是从根节点开始一个一个字符进行比较：如果沿路比较，发现不同的字符，则表示该字符串在集合中不存在。如果所有的字符全部比较完并且全部相同，还需判断最后一个节点的标志位（标记该节点是否代表一个关键字）。

例题

1、677-键值映射

实现一个 MapSum 类，支持两个方法，insert 和 sum：

• MapSum() 初始化 MapSum 对象
• void insert(String key, int val) 插入 key-val 键值对，字符串表示键 key ，整数表示值 val 。如果键 key 已经存在，那么原来的键值对将被替代成新的键值对。
• int sum(string prefix) 返回所有以该前缀 prefix 开头的键 key 的值的总和。

示例：

输入：
["MapSum", "insert", "sum", "insert", "sum"]
[[], ["apple", 3], ["ap"], ["app", 2], ["ap"]]
输出：
[null, null, 3, null, 5]

解释：
MapSum mapSum = new MapSum();
mapSum.insert("apple", 3);  
mapSum.sum("ap");           // return 3 (apple = 3)
mapSum.insert("app", 2);    
mapSum.sum("ap");           // return 5 (apple + app = 3 + 2 = 5)

提示：

• 1 <= key.length, prefix.length <= 50
• key 和 prefix 仅由小写英文字母组成
• 1 <= val <= 1000
• 最多调用 50 次 insert 和 sum

解答

class MapSum {
    private boolean isWord=false;
    private MapSum next[]=new MapSum[26];
    private int val=0;
    /** Initialize your data structure here. */
    public MapSum() {

    }
    
    public void insert(String key, int val) {
        MapSum root=this;
        for(char c:key.toCharArray()){
            if(root.next[c-'a']==null)root.next[c-'a']=new MapSum();
            root=root.next[c-'a'];
        }
        root.isWord=true;
        root.val=val;
    }
    
    public int sum(String prefix) {
        MapSum root=this;
        for(char c:prefix.toCharArray()){
            if(root.next[c-'a']==null) return 0;
            root=root.next[c-'a'];
        }
        return count(root);
    }
    public int count(MapSum root){
        if(root==null) return 0;
        int res=0;
        if(root.isWord) res+=root.val;
        for(int i=0;i<26;i++){
            res+=count(root.next[i]);
        }
        return res;
    }
}

/**
 * Your MapSum object will be instantiated and called as such:
 * MapSum obj = new MapSum();
 * obj.insert(key,val);
 * int param_2 = obj.sum(prefix);
 */

2、面试题 17.17. 多次搜索

给定一个较长字符串big和一个包含较短字符串的数组smalls，设计一个方法，根据smalls中的每一个较短字符串，对big进行搜索。输出smalls中的字符串在big里出现的所有位置positions，其中positions[i]为smalls[i]出现的所有位置。

示例：

输入：
big = "mississippi"
smalls = ["is","ppi","hi","sis","i","ssippi"]
输出： [[1,4],[8],[],[3],[1,4,7,10],[5]]

提示：

• 0 <= len(big) <= 1000
• 0 <= len(smalls[i]) <= 1000
• smalls的总字符数不会超过 100000。
• 你可以认为smalls中没有重复字符串。
• 所有出现的字符均为英文小写字母。

思路

用smalls数组构建一颗前缀树，然后用big的字串去遍历它，例如先找m开头的有没有符合的，再找i开头的。trie树中把原本的isword属性改成smalls中字符串的下标，不是字符串的置为-1。这样遍历的时候如果碰到isword大于等于0的就说明这是一个smalls里的字符串。

代码

class Solution {
    public int[][] multiSearch(String big, String[] smalls) {
        int[][] res = new int[smalls.length][];
        if (big.length() == 0 || smalls.length == 0) {
            res = new int[smalls.length][0];
            return res;
        }
		//smalls插入前缀树
        Trie root=new Trie();
        for(int i=0;i<smalls.length;i++){
            String str=smalls[i];
            root.insert(str,i);
        }
        
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        for(int i = 0 ; i < smalls.length ; i++){
            list.add(new ArrayList<Integer>());
        }
        
		//搜索
        char bigArray[]=big.toCharArray();
        for(int i=0;i<bigArray.length;i++){
            Trie temp=root;
            int j=i;
            while(j<bigArray.length && temp.next[bigArray[j]-'a']!=null){
                if(temp.next[bigArray[j]-'a'].val>=0) list.get(temp.next[bigArray[j]-'a'].val).add(i);
                temp=temp.next[bigArray[j]-'a'];
                j+=1;
            }
        }
        

        // list转数组
        for (int i=0; i<list.size(); ++i) {
            res[i] = new int[list.get(i).size()];
            for (int j=0; j<list.get(i).size(); ++j) {
                res[i][j] = list.get(i).get(j);
            }
        }
        return res;
    }
}
public class Trie {
    public int val=-1;
    public Trie next[]=new Trie[26];

    public Trie(){}

    public void insert(String word,int index){
        Trie root=this;
        for(char w:word.toCharArray()){
            if(root.next[w-'a']==null)root.next[w-'a']=new Trie();
            root=root.next[w-'a'];
        }
        root.val=index;
    }
}