字典树

• 首页
• 博客
• 学院
• 下载
• GitChat
• TinyMind
• 商城
• VIP

• 写博客
• 发Chat
• 

jiutianhe的专栏

声明：本博客乃学习笔记，没有纯粹无意义的转载。作者除了对自己负责，不对任何读者负责，欢迎指出文章错误...

RSS订阅

个人资料

jiutianhe

关注

原创

93

粉丝

143

喜欢

9

评论

51

等级：

访问：

66万+

积分：

6125

排名：

5220

勋章：

最新文章

• MSYS2的源配置
• 文本分类,数据挖掘和机器学习
• JDK7新特性--NIO2.0 文件系统
• 2014年国人开发的最热门的开源软件TOP 100
• java的concurrent用法详解

个人分类

• 操作系统4篇
• 网络1篇
• 数据结构34篇
• C语言基础2篇
• Java49篇
• Java基本功知识23篇
• Linux系统8篇
• 机器学习24篇
• 软件知识34篇
• 数据库25篇
• 个人爱好7篇
• hapoop16篇
• Python3篇
• Apache14篇
• 图像处理7篇
• java插件3篇
• 算法1篇

展开

归档

• 2015年8月1篇
• 2015年6月1篇
• 2015年5月1篇
• 2015年4月2篇
• 2015年3月1篇
• 2015年2月2篇
• 2015年1月9篇
• 2014年12月16篇
• 2014年11月19篇
• 2014年10月37篇
• 2014年9月19篇
• 2014年8月11篇
• 2014年7月1篇
• 2014年6月22篇
• 2014年5月5篇
• 2014年4月8篇
• 2014年3月1篇
• 2014年2月4篇
• 2014年1月6篇
• 2013年12月10篇
• 2013年11月1篇
• 2013年10月10篇
• 2013年9月3篇
• 2013年8月1篇
• 2013年7月4篇
• 2013年5月1篇
• 2013年4月8篇
• 2012年12月1篇
• 2012年11月2篇
• 2012年10月21篇
• 2012年9月12篇

展开

热门文章

• 图像相似度算法--SIFT算法详解

  阅读量：80718

• java队列实现（顺序队列、链式队列、循环队列）

  阅读量：29416

• Java使用commons-dbcp2.0

  阅读量：27190

• eclipse 运行Maven时报错总结

  阅读量：26410

• Apache Commons Codec 编码解码

  阅读量：21256

最新评论

• Java String之Strin...

  wanghuawei19930812：Error:(19, 79) java: 不兼容的类型: java.lang.CharSequen...

• 最短路径的Floyd与Dijkst...

  lavystord：优先队列的实现是错的....

• java队列实现（顺序队列、链式队...

  passagebird：厉害！

• eclipse 运行Maven时报...

  u013300472：更新一下。试试 看看是不是确实包或者没有继承

• Trie树（字典树）

  zhzxlc_06：TrieTree 类 第36行 写错了，应该是 node.child[pos].ch=letter...

联系我们

请扫描二维码联系客服

[email protected]

400-660-0108

QQ客服 客服论坛

关于招聘广告服务  百度

©1999-2018 CSDN版权所有

京ICP证09002463号

经营性网站备案信息

网络110报警服务

中国互联网举报中心

北京互联网违法和不良信息举报中心

原

Trie树（字典树）

2012年10月16日 13:56:13

阅读数：21317

1. Trie树

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

Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。

它有3个基本性质：

1. 根节点不包含字符，除根节点外每一个节点都只包含一个字符。
2. 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串。
3. 每个节点的所有子节点包含的字符都不相同。

2. 字典树的构建

       题目：给你100000个长度不超过10的单词。对于每一个单词，我们要判断他出没出现过，如果出现了，求第一次出现在第几个位置。
分析：这题当然可以用hash来解决，但是本文重点介绍的是trie树，因为在某些方面它的用途更大。比如说对于某一个单词，我们要询问它的前缀是否出现过。这样hash就不好搞了，而用trie还是很简单。
假设我要查询的单词是abcd，那么在他前面的单词中，以b，c，d，f之类开头的我显然不必考虑。而只要找以a开头的中是否存在abcd就可以了。同样的，在以a开头中的单词中，我们只要考虑以b作为第二个字母的，一次次缩小范围和提高针对性，这样一个树的模型就渐渐清晰了。
好比假设有b，abc，abd，bcd，abcd，efg，hii 这6个单词，我们构建的树就是如下图这样的：

ok，如上图所示，对于每一个节点，从根遍历到他的过程就是一个单词，如果这个节点被标记为 红色，就表示这个单词存在，否则不存在。
那么，对于一个单词，我只要顺着他从根走到对应的节点，再看这个节点是否被标记为红色就可以知道它是否出现过了。把这个节点标记为红色，就相当于插入了这个单词。
       这样一来我们查询和插入可以一起完成（重点体会这个查询和插入是如何一起完成的，稍后，下文具体解释），所用时间仅仅为单词长度，在这一个样例，便是10。
我们可以看到，trie树每一层的节点数是26^i级别的。所以为了节省空间。我们用动态链表，或者用数组来模拟动态。空间的花费，不会超过单词数×单词长度。

      已知n个由小写字母构成的平均长度为10的单词,判断其中 是否存在某个串为另一个串的前缀子串。下面对比3种方法：

1. 最容易想到的：即从字符串集中从头往后搜，看每个字符串是否为字符串集中某个字符串的前缀，复杂度为O(n^2)。
2. 使用hash：我们用hash存下所有字符串的所有的前缀子串，建立存有子串hash的复杂度为O(n*len)，而查询的复杂度为O(n)* O(1)= O(n)。
3. 使用trie：因为当查询如字符串abc是否为某个字符串的前缀时，显然以b,c,d....等不是以a开头的字符串就不用查找了。所以建立trie的复杂度为O(n*len)，而建立+查询在trie中是可以同时执行的，建立的过程也就可以成为查询的过程，hash就不能实现这个功能。所以总的复杂度为O(n*len)，实际查询的复杂度也只是O(len)。（说白了，就是Trie树的平均高度h为len，所以Trie树的查询复杂度为O（h）=O（len）。好比一棵二叉平衡树的高度为logN，则其查询，插入的平均时间复杂度亦为O（logN））。

3. 查询

Trie树是简单但实用的数据结构，通常用于实现字典查询。我们做即时响应用户输入的AJAX搜索框时，就是Trie开始。本质上，Trie是一颗存储多个字符串的树。相邻节点间的边代表一个字符，这样树的每条分支代表一则子串，而树的叶节点则代表完整的字符串。和普通树不同的地方是，相同的字符串前缀共享同一条分支。下面，再举一个例子。给出一组单词，inn, int, at, age, adv, ant, 我们可以得到下面的Trie：

可以看出：

• 每条边对应一个字母。
• 每个节点对应一项前缀。叶节点对应最长前缀，即单词本身。
• 单词inn与单词int有共同的前缀“in”, 因此他们共享左边的一条分支，root->i->in。同理，ate, age, adv, 和ant共享前缀"a"，所以他们共享从根节点到节点"a"的边。

查询操纵非常简单。比如要查找int，顺着路径i -> in -> int就找到了。

搭建Trie的基本算法也很简单，无非是逐一把每则单词的每个字母插入Trie。插入前先看前缀是否存在。如果存在，就共享，否则创建对应的节点和边。比如要插入单词add，就有下面几步：

1. 考察前缀"a"，发现边a已经存在。于是顺着边a走到节点a。
2. 考察剩下的字符串"dd"的前缀"d"，发现从节点a出发，已经有边d存在。于是顺着边d走到节点ad
3. 考察最后一个字符"d"，这下从节点ad出发没有边d了，于是创建节点ad的子节点add，并把边ad->add标记为d。

4. 应用

• 1、有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16字节，内存限制大小是1M。返回频数最高的100个词。
• 2、1000万字符串，其中有些是重复的，需要把重复的全部去掉，保留没有重复的字符串。请怎么设计和实现？
• 3、 一个文本文件，大约有一万行，每行一个词，要求统计出其中最频繁出现的前10个词，请给出思想，给出时间复杂度分析。
• 4、寻找热门查询：搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。假设目前有一千万个记录，这些查询串的重复读比较高，虽然总数是1千万，但是如果去除重复和，不超过3百万个。一个查询串的重复度越高，说明查询它的用户越多，也就越热门。请你统计最热门的10个查询串，要求使用的内存不能超过1G。
  (1) 请描述你解决这个问题的思路；
  (2) 请给出主要的处理流程，算法，以及算法的复杂度。

5. 代码实现(Java)

package binarytree;

/**
 * 字典树的Java实现。实现了插入、查询以及深度优先遍历.
 * Trie tree's java implementation.(Insert,Search,DFS)
 * @author jiutianhe
 * @time 2012.10.16
 */
public class TrieTree {
    final int MAX_SIZE=26;
    public class TrieTreeNode {
        int nCount;//记录该字符出现次数
        char ch; //记录该字符
        TrieTreeNode[] child;

        public TrieTreeNode() {
            nCount=1;
            child=new TrieTreeNode[MAX_SIZE];
        }


    }
    //字典树的插入和构建
    public void createTrie(TrieTreeNode node,String str){
        if (str==null||str.length()==0) {
            return;
        }
        char[] letters=str.toCharArray();
        for (int i = 0; i < letters.length; i++) {
            int pos = letters[i] - 'a';
            if (node.child[pos] == null) {
                node.child[pos] = new TrieTreeNode();
            }else {
                node.child[pos].nCount++;
            }
            node.ch=letters[i];
            node = node.child[pos];
        }
    }
    //字典树的查找
    public int findCount(TrieTreeNode node,String str){
        if (str==null||str.length()==0) {
            return -1;
        }
        char[] letters=str.toCharArray();
        for (int i = 0; i < letters.length; i++) {
            int pos = letters[i] - 'a';
            if (node.child[pos] == null) {
                return 0;
            }else {
                node=node.child[pos];
            }
        }
        return node.nCount;
    }

}

@Test
    public void trieTreeTest2(){
    /**
     * Problem Description
     * 老师交给他很多单词(只有小写字母组成,不会有重复的单词出现),现在老师要他统计
     * 出以某个字符串为前缀的单词数量(单词本身也是自己的前缀).
     */
        String[] strs={
                "banana",
                "band",
                "bee",
                "absolute",
                "acm",
        };
        String[] prefix={
            "ba",
            "b",
            "band",
            "abc",
        };
        TrieTree tree = new TrieTree();
        TrieTreeNode root=tree.new TrieTreeNode();

        for (String s : strs) {
            tree.createTrie(root, s);
        }
//        tree.printAllWords();
        for(String pre:prefix){
            int num=tree.findCount(root,pre);
            System.out.println(pre+" "+num);
        }

    }

代码2：

package com.algorithm;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 *
 *
 * Title:
 *
 *
 * Description: 单词Trie树
 *
 *
 * @createDate：2013-10-17
 * @author
 * @version 1.0
 */
public class WordTrie {
    class TrieNode {
        /**
         * trie tree word count
         */
        int count = 0;

        /**
         * trie tree prefix count
         */
        int prefixCount = 0;

        /**
         * 指向各个子树的指针,存储26个字母[a-z]
         */
        TrieNode[] next = new TrieNode[26];

        /**
         * 当前TrieNode状态 ,默认 0 , 1表示从根节点到当前节点的路径表示一个词,即叶子节点
         */
        int nodeState = 0;

        TrieNode() {
            count = 0;
            prefixCount = 0;
            next = new TrieNode[26];
            nodeState = 0;
        }
    }

    /** trie树根 */
    private TrieNode root = new TrieNode();

    /** 英文字符串正则匹配 */
    static String englishPattern = "^[A-Za-z]+$";
    /** 中文正则匹配 */
    static String chinesePattern = "[\u4e00-\u9fa5]";

    static int ARRAY_LENGTH = 26;

    static String zeroString = "";

    /**
     * 插入字串，用循环代替迭代实现
     *
     * @param words
     */
    public void insert(String word) {
        insert(this.root, word);
    }

    /**
     * 插入字串，用循环代替迭代实现
     *
     * @param root
     * @param words
     */
    private void insert(TrieNode root, String word) {
        word = word.toLowerCase();// //转化为小写
        char[] chrs = word.toCharArray();

        for (int i = 0, length = chrs.length; i < length; i++) {
            // /用相对于a字母的值作为下标索引，也隐式地记录了该字母的值
            int index = chrs[i] - 'a';
            if (index >= 0 && index < ARRAY_LENGTH) {//过滤特殊字符，例如`等
                if (root.next[index] != null) {
                    // //已经存在了，该子节点prefixCount++
                    root.next[index].prefixCount++;
                } else {
                    // /如果不存在
                    root.next[index] = new TrieNode();
                    root.next[index].prefixCount++;
                }

                // /如果到了字串结尾，则做标记
                if (i == length - 1) {
                    root.next[index].nodeState = 1;
                    root.next[index].count++;
                }
                // /root指向子节点，继续处理
                root = root.next[index];
            }
        }

    }

    /**
     *
     * @Title: addWord
     * @Description: add word
     * @param @param word
     * @return void
     * @throws
     */
    public void addWord(String word) {
        if (word == null || "".equals(word.trim())) {
            throw new IllegalArgumentException("word can not be null!");
        }
        // if(!word.matches(englishPattern)){
        // System.out.println(word);
        // throw new IllegalArgumentException("word must be english!");
        // }
        addWord(root, word);
    }

    /**
     *
     * @Title: addWord
     * @Description:add word to node
     * @param @param node
     * @param @param word
     * @return void
     * @throws
     */
    private void addWord(TrieNode node, String word) {
        if (word.length() == 0) { // if all characters of the word has been
            // added
            node.count++;
            node.nodeState = 1;
        } else {
            node.prefixCount++;
            char c = word.charAt(0);
            c = Character.toLowerCase(c);
            int index = c - 'a';
            if (index >= 0 && index < ARRAY_LENGTH) {
                if (node.next[index] == null) {
                    node.next[index] = new TrieNode();
                }
                // go the the next character
                addWord(node.next[index], word.substring(1));
            }

        }
    }

    /**
     *
     * @Title: prefixSearchWord
     * @Description: 前缀搜索
     * @param @param word
     * @param @return
     * @return List
     * @throws
     */
    public List prefixSearchWord(String word) {
        if (word == null || "".equals(word.trim())) {
            return new ArrayList();
        }
        if (!word.matches(englishPattern)) {
            return new ArrayList();
        }
        char c = word.charAt(0);
        c = Character.toLowerCase(c);
        int index = c - 'a';
        if (root.next != null && root.next[index] != null) {
            return depthSearch(root.next[index], new ArrayList(),
                    word.substring(1), "" + c, word);
        } else {
            return new ArrayList();
        }
    }

    /**
     *
     * @Title: searchWord
     * @Description: 搜索单词,以a-z为根,分别向下递归搜索
     * @param @param word
     * @param @return
     * @return List
     * @throws
     */
    public List searchWord(String word) {
        if (word == null || "".equals(word.trim())) {
            return new ArrayList();
        }
        if (!word.matches(englishPattern)) {
            return new ArrayList();
        }
        char c = word.charAt(0);
        c = Character.toLowerCase(c);
        int index = c - 'a';
        List list = new ArrayList();
        if (root.next == null) {
            return list;
        }
        for (int i = 0; i < ARRAY_LENGTH; i++) {
            int j = 'a' + i;
            char temp = (char) j;
            if (root.next[i] != null) {
                if (index == i) {
                    fullSearch(root.next[i], list, word.substring(1),
                            "" + temp, word);
                } else {
                    fullSearch(root.next[i], list, word, "" + temp, word);
                }
            }
        }
        return list;
    }

    /**
     *
     * @Title: fullSearch
     * @Description: 匹配到对应的字母,则以该字母为字根,继续匹配完所有的单词。
     * @param @param node
     * @param @param list 保存搜索到的字符串
     * @param @param word 搜索的单词.匹配到第一个则减去一个第一个,连续匹配,直到word为空串.若没有连续匹配,则恢复到原串。
     * @param @param matchedWord 匹配到的单词
     * @param @return
     * @return List
     * @throws
     */
    private List fullSearch(TrieNode node, List list,
            String word, String matchedWord, String inputWord) {
        if (node.nodeState == 1 && word.length() == 0) {
            list.add(matchedWord);
        }
        if (word.length() != 0) {
            char c = word.charAt(0);
            c = Character.toLowerCase(c);
            int index = c - 'a';
            for (int i = 0; i < ARRAY_LENGTH; i++) {
                if (node.next[i] != null) {
                    int j = 'a' + i;
                    char temp = (char) j;
                    if (index == i) {
                        // 连续匹配
                        fullSearch(node.next[i], list, word.substring(1),
                                matchedWord + temp, inputWord);
                    } else {
                        // 未连续匹配,则重新匹配
                        fullSearch(node.next[i], list, inputWord, matchedWord
                                + temp, inputWord);
                    }
                }
            }
        } else {
            if (node.prefixCount > 0) {
                for (int i = 0; i < ARRAY_LENGTH; i++) {
                    if (node.next[i] != null) {
                        int j = 'a' + i;
                        char temp = (char) j;
                        fullSearch(node.next[i], list, zeroString, matchedWord
                                + temp, inputWord);
                    }
                }
            }
        }
        return list;
    }

    /**
     *
     * @Title: depthSearch
     * @Description: 深度遍历子树
     * @param @param node
     * @param @param list 保存搜索到的字符串
     * @param @param word 搜索的单词.匹配到第一个则减去一个第一个,连续匹配,直到word为空串.若没有连续匹配,则恢复到原串。
     * @param @param matchedWord 匹配到的单词
     * @param @return
     * @return List
     * @throws
     */
    private List depthSearch(TrieNode node, List list,
            String word, String matchedWord, String inputWord) {
        if (node.nodeState == 1 && word.length() == 0) {
            list.add(matchedWord);
        }
        if (word.length() != 0) {
            char c = word.charAt(0);
            c = Character.toLowerCase(c);
            int index = c - 'a';
            // 继续完全匹配,直到word为空串,否则未找到
            if (node.next[index] != null) {
                depthSearch(node.next[index], list, word.substring(1),
                        matchedWord + c, inputWord);
            }
        } else {
            if (node.prefixCount > 0) {// 若匹配单词结束,但是trie中的单词并没有完全找到,需继续找到trie中的单词结束.
                // node.prefixCount>0表示trie中的单词还未结束
                for (int i = 0; i < ARRAY_LENGTH; i++) {
                    if (node.next[i] != null) {
                        int j = 'a' + i;
                        char temp = (char) j;
                        depthSearch(node.next[i], list, zeroString, matchedWord
                                + temp, inputWord);
                    }
                }
            }
        }
        return list;
    }

    /**
     * 遍历Trie树，查找所有的words以及出现次数
     *
     * @return HashMap map
     */
    public Map getAllWords() {
        return preTraversal(this.root, "");
    }

    /**
     * 前序遍历。。。
     *
     * @param root
     *            子树根节点
     * @param prefixs
     *            查询到该节点前所遍历过的前缀
     * @return
     */
    private Map preTraversal(TrieNode root, String prefixs) {
        Map map = new HashMap();

        if (root != null) {

            if (root.nodeState == 1) {
                // //当前即为一个单词
                map.put(prefixs, root.count);
            }

            for (int i = 0, length = root.next.length; i < length; i++) {
                if (root.next[i] != null) {
                    char ch = (char) (i + 'a');
                    // //递归调用前序遍历
                    String tempStr = prefixs + ch;
                    map.putAll(preTraversal(root.next[i], tempStr));
                }
            }
        }

        return map;
    }

    /**
     * 判断某字串是否在字典树中
     *
     * @param word
     * @return true if exists ,otherwise false
     */
    public boolean isExist(String word) {
        return search(this.root, word);
    }

    /**
     * 查询某字串是否在字典树中
     *
     * @param word
     * @return true if exists ,otherwise false
     */
    private boolean search(TrieNode root, String word) {
        char[] chs = word.toLowerCase().toCharArray();
        for (int i = 0, length = chs.length; i < length; i++) {
            int index = chs[i] - 'a';
            if (root.next[index] == null) {
                // /如果不存在，则查找失败
                return false;
            }
            root = root.next[index];
        }

        return true;
    }
}

测试和计算词频中最大n个

package com.algorithm;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;

public class WordTrieMain {

    public static void main(String[] args){
        wordMaxNFrequency(10);
    }

    public static void test1(){
        WordTrie trie=new WordTrie();

        trie.addWord("ibiyzbi");

        System.out.println("----------------------------------------");
        List words=trie.searchWord("bi");
        for(String s: words){
            System.out.println(s);
        }
    }

    public static void test(){
        WordTrie trie=new WordTrie();
        trie.addWord("abi");
        trie.addWord("ai");
        trie.addWord("aqi");
        trie.addWord("biiiyou");
        trie.addWord("dqdi");
        trie.addWord("ji");
        trie.addWord("li");
        trie.addWord("li");
        trie.addWord("li");
        trie.addWord("lipi");
        trie.addWord("qi");
        trie.addWord("qibi");
        trie.addWord("i");
        trie.addWord("ibiyzbi");
        List list=trie.prefixSearchWord("li");
        for(String s: list){
            System.out.println(s);
        }
        System.out.println("----------------------------------------");
        System.out.println(trie.getAllWords());
        System.out.println("----------------------------------------");
        List li=trie.searchWord("i");
        for(String s: li){
            System.out.println(s);
        }
        System.out.println("----------------------------------------");
        List words=trie.searchWord("bi");
        for(String s: words){
            System.out.println(s);
        }

        System.out.println("----------------------------------------");
        List lst=trie.searchWord("q");
        for(String s: lst){
            System.out.println(s);
        }
    }

    /**
     * @Title: wordMaxNFrequency
     * @Description: 计算文章词频中最大的前N个
     * @param     设定文件
     * @return void    返回类型
     * @throws
     */
    public static void wordMaxNFrequency(int n){
//      InputStream is = new WordTrieMain().getClass().getClassLoader().getResourceAsStream("words.txt");
        BufferedReader br = null;
        try {
            File file= new File("src/com/algorithm/words.txt");
            //读取语料库words.txt
            br = new BufferedReader(new InputStreamReader(new FileInputStream(file.getAbsolutePath()),"GBK"));
            String word="";
            WordTrie trie=new WordTrie();
            while ((word = br.readLine()) != null) {
                trie.insert(word);;
            }
            Map map = trie.getAllWords();
            System.out.println(map.get("the"));
            PriorityQueue> pq=new PriorityQueue>(10,new Comparator>() {
                @Override
                public int compare(Map.Entry o1,
                        Map.Entry o2) {
                    return o1.getValue().compareTo(o2.getValue());
                }
            });
            int i =0;
            for(Entry entry : map.entrySet()){
                if(i
                    pq.offer(entry);
                }else{
                    Entry entryTemp =  (Entry) pq.peek();
                    if(entryTemp.getValue().compareTo(entry.getValue())<0){
                        pq.poll();
                        pq.offer(entry);

                    }
                }
                i++;
            }
            System.out.println(pq.toString());
        }catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }
        finally{
            try{
                br.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

Trie树占用内存较大，例如：处理最大长度为20、全部为小写字母的一组字符串，则可能需要  个节点来保存数据。而这样的树实际上稀疏的十分厉害，可以采用左儿子右兄弟的方式来改善，也可以采用需要多少子节点则添加多少子节点来解决（不要类似网上的示例，每个节点初始化时就申请一个长度为26的数组）。

Wiki上提到了采用三数组Trie(Tripple-Array Trie)和二数组Trie(Double-Array Trie)来解决该问题，此外还有压缩等方式来缓解该问题。

package com.recommend.base.algorithm;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
import java.util.TreeMap;

import org.apache.commons.lang3.StringUtils;

public class Trie {

    private TrieNode root; //根节点

    public Trie() {
        this.root = new TrieNode();
    }

    private class TrieNode { //节点类
        private int num; //通过的字符串数（包含在此结束的字符串）
        private int count; //刚好在这里结束的单词数
        private Map son; //记录子节点

        TrieNode() {
            num = 1;
            count = 0;
            son = new TreeMap<>(); //TreeMap用于排序
        }
    }

    public void add(String word) {  //在字典树中插入一个字符串
        if(StringUtils.isBlank(word)) {
            return;
        }
        TrieNode node = root;
        char[] letters = word.toCharArray();
        for(char c : letters) {
            if(node.son.containsKey(c)) {
                node.son.get(c).num++;
            } else {
                node.son.put(c, new TrieNode());
            }
            node = node.son.get(c);
        }
        node.count++;
    }

    public int countWord(String word) { //计算字符串出现的次数
        return count(word, false);
    }

    public int countPrefix(String prefix) { //计算前缀出现的次数
        return count(prefix, true);
    }

    public boolean contain(String word) { //是否含有字符串
        return count(word, false) > 0;
    }

    public int count(String word, boolean isPrefix) { //计算字符串/前缀出现的次数
        if(StringUtils.isBlank(word))
            return 0;
        TrieNode node = root;
        char[] letters = word.toCharArray();
        for(char c : letters) {
            if(node.son.containsKey(c))
                node = node.son.get(c);
            else
                return 0;
        }
        return isPrefix? node.num: node.count;
    }

    public Map getSortedWordsAndCounts() { //获取排序号的字符串和其出现次数
        Map map = new TreeMap<>();
        getSortedWordsAndCounts(root, map, StringUtils.EMPTY);
        return map;
    }
    private void getSortedWordsAndCounts(TrieNode node, Map map, String pre) {
        for(Map.Entry e: node.son.entrySet()) {
            String prefix = pre + e.getKey();
            if(e.getValue().count > 0) {
                map.put(prefix, e.getValue().count);
            }
            getSortedWordsAndCounts(e.getValue(), map, prefix);
        }
    }

    public Collection getSortedWords() { //获取排好序的字符串
        Collection list = new ArrayList<>();
        getSortedWords(root, list, StringUtils.EMPTY);
        return list;
    }
    private void getSortedWords(TrieNode node, Collection list, String pre) {
        for(Map.Entry e: node.son.entrySet()) {
            String prefix = pre + e.getKey();
            if(e.getValue().count > 0) {
                list.add(prefix);
            }
            getSortedWords(e.getValue(), list, prefix);
        }
    }

    public String getMaxCommonPrefix() { //获取最大公共前缀
        TrieNode node = root;
        String maxPrefix = StringUtils.EMPTY;
        while(node.son.size() == 1 && node.count == 0) {
            for(Map.Entry e: node.son.entrySet()) {
                node = e.getValue();
                maxPrefix += e.getKey();
            }
        }
        return maxPrefix;
    }

    public static void main(String[] args) { //测试
        Trie trie = new Trie();
//        trie.add("he");
        trie.add("hf");
        trie.add("hfz");
        trie.add("hfz");
        trie.add("hfz");
        trie.add("hfzy");
//        trie.add("hg");
//        trie.add("eh");
//        trie.add("eh");
//        trie.add("ek");

        System.out.println(trie.countWord("hfz"));
        System.out.println(trie.countPrefix("hfz"));
        System.out.println(trie.contain("eh"));
        System.out.println(trie.getSortedWords());
        System.out.println(trie.getSortedWordsAndCounts());
        System.out.println(trie.getMaxCommonPrefix());
    }

}

文章标签：  string 搜索引擎 null 算法 java

个人分类：  数据结构

• 
  chaoliu1024 2017-08-02 16:14:03 #2楼

  TrieTree 类 第36行 写错了，应该是 node.child[pos].ch=letters[i];

• 
  郝姬友 2017-07-28 11:44:31 #1楼

  谢谢分享

• 上一页
• 1
• 下一页

【字典树】字典树的创建(入门详细介绍)

Part one【何谓字典树】又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它...

 thesprit

2016-07-29 15:12:16

阅读数：3098

字典树（Trie树）用法及例子（一）

字典树（Trie）概述字典树，又名Trie树。顾名思义，在字典中很好用。我们在查牛津词典时都是先按第一个字母找到以这个字母为首的单词所在的初始位置，在此位置的基础上，再按照第二个字母继续找。。。 插...

 u010902721

2015-05-15 20:53:31

阅读数：5209

字典树(讲解+模板) - CSDN博客

1. Trie树 Trie树,即字典树,又称单词查找树或键树,是一种树形结构,是一种哈希树的变种。典型应用是用于统计和排序大量的字符串(但不仅限于字符串),所以经常...

2018-5-6

ACM常用模板——字典树 - CSDN博客

模型:单词匹配 #include #include #include using...思路:字典树的变形,如存在"abcd",则"bcd", "cd", "d",都需要插入字典树...

2018-5-13

广告

字典树Trie

字典树字典树——Trie树，又称为前缀树（Prefix Tree）、单词查找树或键树，是一种多叉树结构。...

 hihozoo

2016-04-26 11:01:37

阅读数：5150

字典树详细解剖 - CSDN博客

以下内容  为网上复制 及部分的个人理解    Trie树就是字典树,其核心思惟就是空间换时候。 举个简单的例子。 给你100000个长度不跨越10的单词。对于...

2018-5-16

字典树的两种实现 - CSDN博客

字典树 又称单词查找树,Trie树,是一种树形结构,是一种哈希树的变种。典型应用...模型 3篇 dp 14篇 细节 1篇 数据结构 18篇 图论 1篇 矩阵乘法 1...

2018-2-2

字典树算法详解

字典树 字典树，又称单词查找树，Trie树，是一种树形结构，哈希表的一个变种。用于统计，排序和保存大量的字符串（也可以保存其 的）。 优点就是利用公共的前缀来节约存储空间。在这举个简单的例子：比如说...

 piaocoder

2015-08-21 17:11:42

阅读数：4538

字典树

1.字典树 　　曾经遇到这样一个问题：很多单词，这些单词只含小写字母，并且不会有重复的单词出现，现在要统计出以某个字符串为前缀的单词数量，单词本身也是自己的前缀。先看看用常规的方法解决这个问题的复杂...

 mark555

2014-04-12 11:01:09

阅读数：932

字典树 - CSDN博客

转自:http://book.51cto.com/art/201008/220537.htm 8.38  什么是字典树 字典树(Trie)和后缀树是单词处理的最流行数据结构。字典树于1960年由Fredkin作为...

2018-3-25

字典树模板 - CSDN博客

字典树,注意到最后用完字典树的时候把字典树删除,要不容易产生空间不足。 #include...DAG模型硬币问题 558 0 内容举报 返回顶部 收藏助手 不良信息举报 您举报文章...

2018-2-6

01字典树 小结

为了做13年南京网络赛的一道题 学了这个01字典树 看了别人的模板 之后切了几道水题 现在总结一下01字典树的实现可以看成是把一个数的二进制字符化后插入到一颗一般的字典树中比如在01字典树种插入...

 SolarDomo

2016-08-10 10:15:07

阅读数：1746

沈阳竟出了一个炒股美女高手，年仅29岁！凌清色岸 · 顶新

静态字典树(模拟动态的) - CSDN博客

pearson 相关系数 & 机器学习模型中不平衡样本问题 python post请求实例 & json...举报内容: 静态字典树(模拟动态的) 举报原因: 色情 政治 抄袭 广告 招聘 骂...

2018-5-16

Trie树详解及其应用 - CSDN博客

主要转自 http://blog.csdn.net/hackbuteer1/article/details/7964147 一、知识简介        最近在看字符串算法了,其中字典树、AC自动机和...

2018-5-6

海量数据处理之Tire树（字典树）

参考博文：http://blog.csdn.net/v_july_v/article/details/6897097 第一部分、Trie树 1.1、什么是Trie树     Trie树，即字典树...

 ts173383201

2012-08-13 09:02:23

阅读数：20495

静态字典树和动态字典树模板

POJ 3630

 tenlee

2014-08-01 20:24:47

阅读数：994

海量数据处理之Tire树(字典树) - CSDN博客

Trie树,即字典树,又称单词查找树或键树,是一种树形结构,是一种哈希树的变种...考虑以b作为第二个字母的,一次次缩小范围和提高针对性,这样一个树的模型就渐渐...

2018-5-10

字典树 - CE玩家 - CSDN博客

这个子树的SG值用字典树维护所有情况,合并的时候打个标记,然后字典树合并就行...这就是一个经典的2-SAT模型 但是直接做的话,边数是n2n^2级别的,不过因为是...

2018-2-16

字典树C语言实现

字典树 又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字...

 Xiejunyi12

2016-01-30 11:41:57

阅读数：2468

ac自动机最详细的讲解，让你一次学会ac自动机。

在没学ac自动机之前，觉得ac自动机是个很神奇，很高深，很难的算法，学完之后发现，ac自动机确实很神奇，很高深，但是却并不难。 我说ac自动机很神奇，在于这个算法中失配指针的妙处（好比kmp算法中的...

 creatorx

2017-05-02 19:51:08

阅读数：24799

字典树简介和简易应用

1、背景         词汇搜索、词频统计等字符串操作，是搜索引擎、文本处理系统等经常使用的业务，现在假设有这么一个简单的文本处理例子：有一篇10000个词的文章，要查出单词“was”在这篇文章中出...

 ly01kongjian

2013-03-31 16:15:27

阅读数：4258

01字典树专题 （解决异或最大值问题）不断更新ing~

以前一直以为字典树没有多少用，但是最近一直碰到（难道是以前刷题太少的原因么），其中有一类问题叫做01字典树问题，它是用来解决xor的有力武器，通常是给你一个数组，问你一段连续的异或和最大是多少，正常思...

 guhaiteng

2016-08-12 15:12:57

阅读数：2141

01字典树专题

以前一直以为字典树没有多少用，但是最近一直碰到（难道是以前刷题太少的原因么），其中有一类问题叫做01字典树问题，它是用来解决xor的有力武器，通常是给你一个数组，问你一段连续的异或和最大是多少，正常思...

 Miracle_ma

2016-05-23 19:26:51

阅读数：2330

[置顶]AC自动机-算法详解

What's Aho-Corasick automaton? 　　一种多模式串匹配算法，该算法在1975年产生于贝尔实验室，是著名的多模式匹配算法之一。 　　简单的说，KMP用来在一篇文章中匹配一...

 u013371163

2017-03-05 17:35:27

阅读数：4225

[数据结构] 字典树

字典树百度百科：又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用...

 sr19930829

2014-11-21 11:52:23

阅读数：2000

Java实现字典树TrieTree

Java实现字典树TrieTree,可用于计算出四六级试题的高频词.

下载

2015年08月19日 13:00

Tire树（字典树）的基本操作

Tire树的基本原理：     Tire树是一种树形结构，因其是词典的一种存储方式，故又叫字典树。词典中的每一个单 词在tire树中表现为一条从根结点出发的路径，路径边上的点连起来就是一颗tire树，...

 AC_Gibson

2015-04-29 13:20:21

阅读数：2591

Trie Tree 实现中文分词器

前言 继上一篇HashMap实现中文分词器后，对Trie Tree的好奇，又使用Trie Tree实现了下中文分词器。效率比HashMap实现的分词器更高。 Trie Tree 简介 Tri...

 jijianshuai

2017-05-17 23:58:20

阅读数：1502

Trie Tree简单实现

最近突然有兴致hiho一下了，实现了下trie tree，感觉而言，还是挺有意思的，个人觉得这货不光可以用来查单词吧，其实也可以用来替代Hash，反正查找，插入复杂度都挺低的，哈哈，啥都不懂，瞎扯.....

 HURUI123456789

2016-08-17 20:17:24

阅读数：359

高级数据结构的学习与实现之 Trie树，字典树

第一次自学一种新的数据结构，感觉学会利用资源很重要，参考别人写的博客，谷歌搜索一下关于这中数据结构的一些问题，解决等，学会搜索资料，学习并掌握一门数据结构并不是很难。 要知道相关的基本知识，主要应用与...

 guin_guo

2015-10-02 09:43:15

阅读数：1791

• 13

• 
  收藏
• 
  评论
• 
  微信
• 
  微博
• 
  QQ