Java实现字典树 Trie

最新推荐文章于 2023-03-21 12:47:18 发布
最新推荐文章于 2023-03-21 12:47:18 发布
阅读量1.5k 收藏 17
点赞数 3
分类专栏： 数据结构与算法 文章标签： java 开发语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62701287/article/details/126689986
版权

Java实现字典树 Trie

一、字典树介绍

字典树又称为前缀树，是n叉树的特殊形式，广泛应用于统计和排序大量的字符串，它可以很大程度减少无所谓的字符比较，查询效率较高，Trie的核心思想是空间换时间，利用字符串的公共前缀提高查询效率

Trie 的示意图

在这里插入图片描述
从根节点到子节点路径上的字符就是一个字符串的前缀，例如根节点到节点d的经过的路径是d，根节点到节点e经过的路经是de
Trie有如下的特点：

  1. 根节点是一个空字符
  2. 所有节点对应的字符串都与子节点有共同的前缀
  3. 任何节点的孩子节点的值都互不相同

二、Trie实现以及基本的插入查询操作

Trie的实现常见的有数组实现和HashMap实现
这里使用字符串（包括例题）都是由小写字母组成（要是有大写字母，原理相同，修改一些属性就行）

数组实现：

每一个父节点对应的子节点最多有26个，所以我们申请一个26个空间的数组存放子节点

class Trie{
        Trie[] children;
        public Trie(){
            children = new Trie[26];
        } 
    }

这样实现有一个缺点：如果要处理的字符串很少会浪费很多的空间，如下图所示字符串bcy：
在这里插入图片描述

HashMap实现：

class Trie{
        Map<Character,Trie> children;
        public Trie(){
            children = new HashMap<>();
        }
    }

这样实现不会出现空间浪费，但是会比数组实现慢一点

Trie插入（这里都以数组实现为例）：

 Trie root = new Trie();  //根节点
 public void insert(String str){
     Trie node = root;
     for(int i = 0;i < str.length();++i){
         int index = str.charAt(i)-'a';
         if(node.children[index] == null){
             node.children[index] = new Trie();
         }
         node = node.children[index];
     }
 }

Trie查询：

public boolean search(String str){
    Trie node = root;
    for(int i = 0;i < str.length();++i){
        int index = str.charAt(i)-'a';
        if(node.children[index] == null){
            return false;
        }
        node = node.children[index];
    }
    return true;
}

三、相关例题：

1、leetcode 208. 实现 Trie (前缀树)

在这里插入图片描述

这里的search是搜寻单词是不是存在字典树里面，我们可以在Trie加入一个标识isEnd，插入字符串的时候将最后一个字符的isEnd设为true，代表以该节点结尾的前缀是一个完整的单词

class Trie {
    class TreeNode{
        Map<Character,TreeNode> map;
        boolean isEnd;
        public TreeNode(){
            map = new HashMap<>();
        }
    }
    TreeNode root;
    public Trie() {
        root = new TreeNode();
    }
    
    public void insert(String word) {
        TreeNode node = root;
        for(int i = 0;i < word.length();++i){
            char index = word.charAt(i);
            if(!node.map.containsKey(index)){
                node.map.put(index,new TreeNode());
            }
            node = node.map.get(index);
        }
        node.isEnd = true;
    }
    
    public boolean search(String word) {
        TreeNode node = root;
        for(int i = 0;i < word.length();++i){
            char index = word.charAt(i);
            if(!node.map.containsKey(index)){
                return false;
            }
            node = node.map.get(index);
        }
        return node.isEnd == true;
    }
    
    public boolean startsWith(String prefix) {
        TreeNode node = root;
        for(int i = 0;i < prefix.length();++i){
            char index = prefix.charAt(i);
            if(!node.map.containsKey(index)){
                return false;
            }
            node = node.map.get(index);
        }
        return true;
    }
}

/**
 * Your Trie object will be instantiated and called as such:
 * Trie obj = new Trie();
 * obj.insert(word);
 * boolean param_2 = obj.search(word);
 * boolean param_3 = obj.startsWith(prefix);
 */

2、leetcode 677. 键值映射

在这里插入图片描述
在这里插入图片描述

class MapSum {
    class TreeNode{
        Map<Character,TreeNode> map;
        int value;
        public TreeNode(){
            map = new HashMap<>();
        }
        public boolean containsKey(char ch){
            return map.containsKey(ch);
        }
    }
    TreeNode root;
    public MapSum() {
        root = new TreeNode();
    }
    
    public void insert(String key, int val) {
        TreeNode node = root;
        for(int i = 0;i < key.length();++i){
            char ch = key.charAt(i);
            if(!node.containsKey(ch)){
                node.map.put(ch,new TreeNode());
            }
            node = node.map.get(ch);
        }
        node.value = val;
    }
    
    public int sum(String prefix) {
        TreeNode node = root;
        int sum = 0;
        //搜寻前缀为prefix的节点位置
        for(int i = 0;i < prefix.length();++i){
            char ch = prefix.charAt(i);
            if(!node.containsKey(ch)){
                return 0;
            }
            node = node.map.get(ch);
        }
        //使用dfs思想，遍历剩下的所有节点
        sum += dfs(node);
        return sum;
    }
    //dfs返回值表示以node为父节点的所有键值之和
    public int dfs(TreeNode node){
        if(node == null)return 0;
        int sum = node.value;
        Set<Character> keyset = node.map.keySet();
        for(char ch:keyset){
            sum += dfs(node.map.get(ch));
        }
        return sum;
    }
}

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

注意：这里dfs方法里面的sum是局部变量，值不会传递，不需要回溯，与下面的题不一样

3、leetcode 642. 设计搜索自动补全系统

在这里插入图片描述
在这里插入图片描述

解决步骤：
1、处理sentence[i]，和times[i]的时候我们按照平常的思路建树就行，sentence[i]最后一个字符的time = times[i]
2、用StringBuilder类型的对象bu存放input方法加入的字符，当c=='#‘的时候将bu加入到字典树中
3、当c!=’#'时，将c加入到bu中，然后使用和第二题一样的思路查找相同前缀的所有句子
4、使用优先队列（Java自带的有PriorityQueue），存放所有的答案，输出前三个最火的句子

class AutocompleteSystem {
    class TreeNode{
        Map<Character,TreeNode> map;
        int time;
        public TreeNode(){
            map = new HashMap<>();
        }
        public boolean containsKey(char ch){
            return map.containsKey(ch);
        }
    }
    TreeNode root = new TreeNode();
   class StringNode{
       String str;
       int time;
       public StringNode(String str,int time){
           this.str = str;
           this.time = time;
       }
   }
    public AutocompleteSystem(String[] sentences, int[] times) {
        
        int sentenceLen = sentences.length;
        for(int j = 0;j < sentenceLen;++j){
            String str = sentences[j];
            TreeNode node = root;
            for(int i = 0;i < str.length();++i){

                if(!node.containsKey(str.charAt(i))){
                    node.map.put(str.charAt(i),new TreeNode());
                }
                node = node.map.get(str.charAt(i));
            }
            node.time = times[j];
        }
    }
    public void addSentence(StringBuilder bu){
        TreeNode node = root;
        for(int i = 0;i < bu.length();++i){
            char ch = bu.charAt(i);
            if(!node.containsKey(ch)){
                node.map.put(ch,new TreeNode());
            }
            node = node.map.get(ch);
        }
        node.time += 1;
       
    }
    
    StringBuilder bu = new StringBuilder();
    public List<String> input(char c) {
        if(c=='#'){
            addSentence(bu);
            bu = new StringBuilder();
            return new ArrayList<String>();
            
        }
        bu.append(c);
        
        PriorityQueue<StringNode> queue = new PriorityQueue<>(new Comparator<StringNode>(){ //比较器实现
            public int compare(StringNode node1,StringNode node2){
                if(node1.time == node2.time){
                    return node1.str.compareTo(node2.str);
                }
                else{
                    return node2.time-node1.time;
                }
            }
        });
        search(queue);
        List<String> list = new ArrayList<>();
        int size = queue.size()<3?queue.size():3;//如果答案少于三个，全部输出
        for(int i = 0;i < size;++i){
            list.add(queue.poll().str);
        }
        return list;
    }
    //确定前缀的位置
    public void search(PriorityQueue<StringNode> queue){
        TreeNode node = root;
        StringBuilder temp = new StringBuilder();
        for(int i = 0;i < bu.length();++i){
            char ch = bu.charAt(i);
            if(!node.containsKey(ch))return;//如果没有这个前缀直接返回
            temp.append(ch);
            node = node.map.get(ch);
        }
        //搜寻所有答案
        dfs(node,temp,queue);
        

    }
    //搜索所有的答案
    public void dfs(TreeNode node,StringBuilder temp,PriorityQueue<StringNode> queue){
    	//如果该字符串是句子，加入
        if(node.time!=0){
            queue.offer(new StringNode(new String(temp),node.time));
        }
        Set<Character> keyset = node.map.keySet();
        for(char ch:keyset){
            temp.append(ch);
            dfs(node.map.get(ch),temp,queue);
            temp.deleteCharAt(temp.length()-1);//回溯
        }
    }
}

/**
 * Your AutocompleteSystem object will be instantiated and called as such:
 * AutocompleteSystem obj = new AutocompleteSystem(sentences, times);
 * List<String> param_1 = obj.input(c);
 */

注意：在搜索所有答案的时候要回溯，因为bu是StringBuilder类型的对象，传递的时候值改变了

总结：

字典树的用法不止这些，需要自己刷题积累

J沉淀
关注
  • 3
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现字典树TrieTree
08-19
Java实现字典树TrieTree,可用于计算出四六级试题的高频词.
Trie的java实现
gaofen100
11-17 188
关注Trie 这种结构已经很久，Trie有一个很有趣的用途，那就是自动提示。而且，前不久在一次面试里，也需要用Trie来解答。所以，在此对这个数据结构进行总结。 Trie，又称单词查找树或键树，是一种树形结构。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。 它有3个基...
java trie树
我的技术旅程
11-13 139
字典树查找，Trie,又称字典树、单词查找树,是一种树形结构，用于保存大量的字符串。它的优点是：利用字符串的公共前缀来节约存储空间。   package com.jwetherell.algorithms.data_structures; import java.util.Arrays; /** * A trie, or prefix tree, is an ordered...
java 版字典树
lyloric的专栏
04-08 342
public class Main {     public static void main(String[] args) {         String[] str = { "asdf", "asji", "bjkl", "cdsdf", "jdsfk" };         Trie root = new Trie();         for (String s : str) {
字典树实例--java实现
04-23
NULL 博文链接：https://709002341.iteye.com/blog/2260944
Trie树(字典树)的介绍及Java实现
08-31
Trie树，又称字典树或前缀树，关于它的结构就不详细介绍了。Trie树在单词统计、前缀匹配等很多方面有很大用处。下面这篇文章主要介绍了Trie树，以及Java实现如何Trie树，有需要的朋友可以参考借鉴，下面来一起看看吧...
基于Java链表实现的字典树（trie）
05-02
基于Java链表实现的字典树（trie），实现了增删改查等功能，它说摘要必须大于50字我还能说啥啥啥啥
一棵Java字典树（trie）和它的增删改查
01-20
一棵用List来存储子结点的字典树——当然，也可以用哈希表等形式存储。 这篇笔记记录了构建思路，文末是源码 一、构建思路 Step1 设计结点——数据结构 Step2 实现相应的操作方法——增删改查 Step1 设计结点 我们...
详解字典树Trie结构及其Python代码实现
01-21
字典树（Trie）可以保存一些字符串->值的对应关系。基本上，它跟 Java 的 HashMap 功能相同，都是 key-value 映射，只不过 Trie 的 key 只能是字符串。 Trie 的强大之处就在于它的时间复杂度。它的插入和查询时间...
字典树（java）
qq_43413774的博客
05-16 1032
目录什么是字典树字典树的基本性质如下：字典树的应用字典树的实现插入（insert）java代码：查询完整代码： 什么是字典树 字典树（又叫单词查找树、TrieTree），是一种树形结构，典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串,如01字典树）。主要思想是利用字符串的公共前缀来节约存储空间。很好地利用了串的公共前缀，节约了存储空间。字典树主要包含两种操作，插入和查找。 其实很好理解，小时候我们都用过英语字典，前面有个目录，目录里的内容就是字典树 字典树的基本性质如下： 根节点没有字
java 字典树的实现
白纸
02-06 104
牛客题目链接 1. 题目考点 HashMap 的使用 2. 考点解析 public String[] trieU (String[][] operators) { // write code here HashMap<String, Integer> map = new HashMap<>(); StringBuilder sb = new StringBuilder(); for (int i = 0; i < operators
Mysql前缀树_字典树（前缀树）-Java实现
weixin_29334463的博客
01-28 99
字典树字典树是一种树形结构，优点是利用字符串的公共前缀来节约存储空间。在这提供一个自己写的Java实现，非常简洁。根节点没有字符路径。除根节点外，每一个节点都被一个字符路径找到。从根节点到某一节点，将路径上经过的字符连接起来，为对应字符串。每个节点向下所有的字符路径上的字符都不同每个结点维持两个变量的记录：path表示字符路过这个结点的次数(即表示存在以当前结点为前缀的字符有多少个)；end记录以...
Java实现字典树
lhfight的专栏
07-26 1298
package D0726; public class T { public static void main(String[] args) { String[] str = { "asdf", "asji", "bjkl", "cdsdf", "jdsfk" }; Trie root = new Trie(); for (St
前缀树(字典树/Trie) -----Java实现
qq_64580912的博客
03-21 1422
字典树（Trie树）是一种，常用于。字典树的核心思想是。它是一棵，每个代表一个，从。字典树的，每个，从根节点到任意一个节点所经过的路径上的字符连接起来即为该节点所代表的字符串。每个节点可以存储一个或多个字符串，通常使用一个。当需要在一组字符串中查找某个字符串时，可以利用字典树来实现高效的查找操作。
字典树的Java实现
Lolita1997的博客
07-24 317
又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串(但不仅限于字符串)，所以经常被搜索引擎系统用于文本词频统计。它的优点是:利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。时间复杂度O（m）m为单词字母的个数； 数据结构： class TrieNode { char da...
字典树Java实现
weixin_34233618的博客
11-12 206
Trie树的原理 　　Trie树也称字典树，因为其效率很高，所以在在字符串查找、前缀匹配等中应用很广泛，其高效率是以空间为代价的。 　　利用串构建一个字典树，这个字典树保存了串的公共前缀信息，因此可以降低查询操作的复杂度。下面以英文单词构建的字典树为例，这棵Trie树中每个结点包括26个孩子结点，因为总共有26个英文字母(假设单词都是小写字母组成)。 详细介绍请参考：http://www.c...
字典树（java实现）
XD_fybdw的博客
07-21 7275
一、什么是java字典树？ Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。 Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。 它有3个基本性质： 1...
Java 数据结构与算法中的字典树你学会了吗？
AS011x的博客
09-14 306
Trie 的历史字典树 Trie 这个词来自于 retrieval，于 1912 年，Axel Thue 首次抽象地描述了一组字符串数据结构的存放方式为 Trie 的想法。这个想法于 1960 年由 Edward Fredkin 独立描述，并创造了 Trie 一词。你看看，多少程序员为了一个词、方法名、属性名，想破脑袋！
Java代码实现Trie字典树查询商品
最新发布
04-19
下面是一个Java代码示例，实现了Trie字典树来查询商品： ``` import java.util.HashMap; import java.util.Map; class TrieNode { Map<Character, TrieNode> children; boolean isEndOfWord; String item; public TrieNode() { children = new HashMap<>(); isEndOfWord = false; } } class Trie { TrieNode root; public Trie() { root = new TrieNode(); } public void insert(String item, String name) { TrieNode current = root; for (int i = 0; i < item.length(); i++) { char ch = item.charAt(i); TrieNode node = current.children.get(ch); if (node == null) { node = new TrieNode(); current.children.put(ch, node); } current = node; } current.isEndOfWord = true; current.item = name; } public String search(String item) { TrieNode current = root; for (int i = 0; i < item.length(); i++) { char ch = item.charAt(i); TrieNode node = current.children.get(ch); if (node == null) { return null; } current = node; } if (current.isEndOfWord) { return current.item; } else { return null; } } } ``` 上面的代码实现了一个Trie字典树类，其中包含了插入商品和查询商品的功能。 在插入商品的时候，把商品名称插入到字典树中，在查询商品的时候，查询商品名称是否存在于字典树中。 这样通过Trie字典树来实现商品查询是一个很高效的方法,在查询时间复杂度为O(n)，n为商品名称的长度.

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值