Trie树（前缀树）的实现与应用

已于 2024-01-27 10:00:05 修改
阅读量315 收藏
点赞数
文章标签： 数据结构 算法 java
于 2023-08-19 21:37:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73939789/article/details/132384554
版权

Trie树，也被称为前缀树，是一种用于处理字符串的数据结构。它可以高效地进行字符串的插入、删除和搜索操作，并且能够快速找到具有相同前缀的字符串。本篇博客将详细介绍Trie树的实现原理和应用场景，并给出Java代码示例。

Trie树的基本结构

Trie树的基本结构由节点和边组成，每个节点表示一个字符，每条边表示一个字符的连接。从根节点到叶子节点的路径表示一个完整的字符串。
在Java代码示例中，我们定义了两种Trie树的实现方式。 Trie1 使用数组作为节点的存储结构， Trie2 使用哈希表作为节点的存储结构。两种实现方式在时间复杂度上没有本质的差异，只是在空间复杂度上有所不同。

Trie树的基本操作

Trie树的基本操作包括插入、删除、搜索和前缀匹配。

插入操作

插入操作用于将一个字符串插入到Trie树中。具体步骤如下：

  1. 从根节点开始，遍历字符串的每个字符。
  2. 对于每个字符，判断是否存在与之对应的子节点。
    • 如果不存在，则创建一个新的节点，并将其作为当前节点的子节点。
    • 如果存在，则将当前节点指向该子节点。
  3. 在遍历完所有字符后，将当前节点的 end 计数加一，表示该字符串的插入次数。

删除操作

删除操作用于从Trie树中删除一个字符串。具体步骤如下：

  1. 首先通过搜索操作判断该字符串是否存在于Trie树中。
  2. 如果存在，则从根节点开始，遍历字符串的每个字符。
  3. 对于每个字符，判断是否存在与之对应的子节点。
    • 如果存在，则将当前节点指向该子节点。
    • 如果不存在，则返回，表示该字符串不存在于Trie树中。
  4. 在遍历完所有字符后，将当前节点的 end 计数减一。
  5. 如果当前节点的 pass 计数为0，表示该节点没有其他字符串经过，可以将其删除。

搜索操作

搜索操作用于判断一个字符串在Trie树中出现的次数。具体步骤如下：

  1. 从根节点开始，遍历字符串的每个字符。
  2. 对于每个字符，判断是否存在与之对应的子节点。
    • 如果存在，则将当前节点指向该子节点。
    • 如果不存在，则返回0，表示该字符串不存在于Trie树中。
  3. 在遍历完所有字符后，返回当前节点的 end 计数，即表示该字符串在Trie树中出现的次数。

前缀匹配操作

前缀匹配操作用于统计所有以给定前缀开头的字符串的出现次数。具体步骤如下：

  1. 从根节点开始，遍历前缀字符串的每个字符。
  2. 对于每个字符，判断是否存在与之对应的子节点。
    • 如果存在，则将当前节点指向该子节点。
    • 如果不存在，则返回0，表示没有以该前缀开头的字符串。
  3. 在遍历完所有字符后，返回当前节点的 pass 计数，即表示所有以该前缀开头的字符串的出现次数。

示例与测试

在代码示例中，我们通过随机生成字符串数组的方式进行了多次测试，分别使用 Trie1 、 Trie2 和 Right （正确的实现方式）进行插入、删除、搜索和前缀匹配操作，并对结果进行了比较验证。
// 示例代码


import java.util.HashMap;

// 该程序完全正确
public class TrieTree {

    public static class Node1 {
        public int pass;//记录字符经过的个数
        public int end;//记录字符结束的个数
        public Node1[] nexts;//节点数组

        // char tmp = 'b'  (tmp - 'a')
        public Node1() {
            pass = 0;
            end = 0;
            nexts = new Node1[26];
        }
    }

    public static class Trie1 {
        private Node1 root;

        public Trie1() {
            root = new Node1();
        }

        public void insert(String word) {
            if (word == null) {
                return;
            }
            char[] str = word.toCharArray();
            Node1 node = root;//头节点
            node.pass++;//有字符经过时
            int path = 0;
            for (int i = 0; i < str.length; i++) { // 从左往右遍历字符
                path = str[i] - 'a'; // 由字符，对应成走向哪条路
                if (node.nexts[path] == null) {
                    node.nexts[path] = new Node1();
                }
                node = node.nexts[path];
                node.pass++;
            }
            node.end++;
        }

        public void delete(String word) {
            if (search(word) != 0) {
                char[] chs = word.toCharArray();
                Node1 node = root;
                node.pass--;
                int path = 0;
                for (int i = 0; i < chs.length; i++) {
                    path = chs[i] - 'a';
                    if (--node.nexts[path].pass == 0) {
                        node.nexts[path] = null;
                        return;
                    }
                    node = node.nexts[path];
                }
                node.end--;
            }
        }

        // word这个单词之前加入过几次
        public int search(String word) {
            if (word == null) {
                return 0;
            }
            char[] chs = word.toCharArray();
            Node1 node = root;
            int index = 0;
            for (int i = 0; i < chs.length; i++) {
                index = chs[i] - 'a';
                if (node.nexts[index] == null) {
                    return 0;
                }
                node = node.nexts[index];
            }
            return node.end;
        }

        // 所有加入的字符串中，有几个是以pre这个字符串作为前缀的
        public int prefixNumber(String pre) {
            if (pre == null) {
                return 0;
            }
            char[] chs = pre.toCharArray();
            Node1 node = root;
            int index = 0;
            for (int i = 0; i < chs.length; i++) {
                index = chs[i] - 'a';
                if (node.nexts[index] == null) {
                    return 0;
                }
                node = node.nexts[index];
            }
            return node.pass;
        }
    }

    public static class Node2 {
        public int pass;
        public int end;
        public HashMap<Integer, Node2> nexts;

        public Node2() {
            pass = 0;
            end = 0;
            nexts = new HashMap<>();
        }
    }

    public static class Trie2 {
        private Node2 root;

        public Trie2() {
            root = new Node2();
        }

        public void insert(String word) {
            if (word == null) {
                return;
            }
            char[] chs = word.toCharArray();
            Node2 node = root;
            node.pass++;
            int index = 0;
            for (int i = 0; i < chs.length; i++) {
                index = (int) chs[i];
                if (!node.nexts.containsKey(index)) {
                    node.nexts.put(index, new Node2());
                }
                node = node.nexts.get(index);
                node.pass++;
            }
            node.end++;
        }

        public void delete(String word) {
            if (search(word) != 0) {
                char[] chs = word.toCharArray();
                Node2 node = root;
                node.pass--;
                int index = 0;
                for (int i = 0; i < chs.length; i++) {
                    index = (int) chs[i];
                    if (--node.nexts.get(index).pass == 0) {
                        node.nexts.remove(index);
                        return;
                    }
                    node = node.nexts.get(index);
                }
                node.end--;
            }
        }

        // word这个单词之前加入过几次
        public int search(String word) {
            if (word == null) {
                return 0;
            }
            char[] chs = word.toCharArray();
            Node2 node = root;
            int index = 0;
            for (int i = 0; i < chs.length; i++) {
                index = (int) chs[i];
                if (!node.nexts.containsKey(index)) {
                    return 0;
                }
                node = node.nexts.get(index);
            }
            return node.end;
        }

        // 所有加入的字符串中，有几个是以pre这个字符串作为前缀的
        public int prefixNumber(String pre) {
            if (pre == null) {
                return 0;
            }
            char[] chs = pre.toCharArray();
            Node2 node = root;
            int index = 0;
            for (int i = 0; i < chs.length; i++) {
                index = (int) chs[i];
                if (!node.nexts.containsKey(index)) {
                    return 0;
                }
                node = node.nexts.get(index);
            }
            return node.pass;
        }
    }

    public static class Right {

        private HashMap<String, Integer> box;

        public Right() {
            box = new HashMap<>();
        }

        public void insert(String word) {
            if (!box.containsKey(word)) {
                box.put(word, 1);
            } else {
                box.put(word, box.get(word) + 1);
            }
        }

        public void delete(String word) {
            if (box.containsKey(word)) {
                if (box.get(word) == 1) {
                    box.remove(word);
                } else {
                    box.put(word, box.get(word) - 1);
                }
            }
        }

        public int search(String word) {
            if (!box.containsKey(word)) {
                return 0;
            } else {
                return box.get(word);
            }
        }

        public int prefixNumber(String pre) {
            int count = 0;
            for (String cur : box.keySet()) {
                if (cur.startsWith(pre)) {
                    count += box.get(cur);
                }
            }
            return count;
        }
    }
    // for test
    public static String generateRandomString(int strLen) {
        char[] ans = new char[(int) (Math.random() * strLen) + 1];
        for (int i = 0; i < ans.length; i++) {
            int value = (int) (Math.random() * 6);
            ans[i] = (char) (97 + value);
        }
        return String.valueOf(ans);
    }

    // for test
    public static String[] generateRandomStringArray(int arrLen, int strLen) {
        String[] ans = new String[(int) (Math.random() * arrLen) + 1];
        for (int i = 0; i < ans.length; i++) {
            ans[i] = generateRandomString(strLen);
        }
        return ans;
    }

    public static void main(String[] args) {
        int arrLen = 100;
        int strLen = 20;
        int testTimes = 100000;
        for (int i = 0; i < testTimes; i++) {
            String[] arr = generateRandomStringArray(arrLen, strLen);
            Trie1 trie1 = new Trie1();
            Trie2 trie2 = new Trie2();
            Right right = new Right();
            for (int j = 0; j < arr.length; j++) {
                double decide = Math.random();
                if (decide < 0.25) {
                    trie1.insert(arr[j]);
                    trie2.insert(arr[j]);
                    right.insert(arr[j]);
                } else if (decide < 0.5) {
                    trie1.delete(arr[j]);
                    trie2.delete(arr[j]);
                    right.delete(arr[j]);
                } else if (decide < 0.75) {
                    int ans1 = trie1.search(arr[j]);
                    int ans2 = trie2.search(arr[j]);
                    int ans3 = right.search(arr[j]);
                    if (ans1 != ans2 || ans2 != ans3) {
                        System.out.println("Oops!");
                    }
                } else {
                    int ans1 = trie1.prefixNumber(arr[j]);
                    int ans2 = trie2.prefixNumber(arr[j]);
                    int ans3 = right.prefixNumber(arr[j]);
                    if (ans1 != ans2 || ans2 != ans3) {
                        System.out.println("Oops!");
                    }
                }
            }
        }
        System.out.println("finish!");

    }

}

总结

Trie树是一种高效的字符串处理数据结构，适用于各种需要快速搜索、插入和删除字符串的场景。本篇博客介绍了Trie树的原理和实现方式，并给出了Java代码示例。希望本篇博客能够帮助读者更好地理解和应用Trie树。
以上就是对Trie树的详细介绍和应用场景的博客。希望对您有所帮助。如有任何疑问，请随时提问。

爱跑步的程序员~
关注
前缀树的设计与实现
虚幻私塾
09-02 380
这个字符串，流程和判断前缀的流程一样，只不过到了末尾位置，判断是否是黑色节点，如果是黑色节点，说明存在这样的字符串，否则不存在。头节点是空串，路径表示字符，节点表示一个字符串的前缀（简称 p 节点），黑色节点表示一个字符串的结尾位置（简称 e 节点）。更进一步，前缀树也可以支持加入元素和删除元素，此时，我们需要在 p 节点和 e 节点记录一个。前缀树即字典树，可以利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较。，如上例，记录次数后，前缀树如下图。的路径，有，则移动指针往。
Trie树(前缀树、字典树)
u011764940的博客
12-16 3088
目录 什么是前缀树 前缀树的优缺点： 前缀树的应用 什么是前缀树 Trie树，又叫字典树、前缀树（Prefix Tree）、单词查找树 或 键树，是一种多叉树结构。如下图： 好比假设有b，abc，abd，bcd，abcd，efg，hii 这6个单词,那我们创建trie树就得到 上图可以归纳出 Trie 树的基本性质： 1. 根节点不包含字符，除根节点外的每一个子节点都包含一个字符。 2. 从根节点到某一个节点，路径上经过的字符连接起来，为该节点对应的字符串。 3. 每个节点的所有子节
数据结构—前缀树Trie的实现原理以及Java代码的实现
终生学习践行者
11-17 1067
详细介绍了前缀树Trie的实现原理以及Java代码的实现。
【java】208. 实现 Trie (前缀树)---用封装集合快速实现！！！
惠菁
04-14 368
Trie（发音类似 “try”）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。 请你实现 Trie 类： Trie() 初始化前缀树对象。 void insert(String word) 向前缀树中插入字符串 word 。 boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。 boolean startsWith(S
Trie树：定义与应用
最新发布
qq_40254606的博客
08-13 761
Trie树是一种用于存储字符串集合的多叉树结构。每个节点代表字符串中的一个字符，而路径代表从根到某个节点的一条字符串。Trie树通过共享公共前缀的方式有效地组织和存储数据，从而在查找和插入操作中获得较高的效率。节点表示字符：每个节点表示一个字符，而路径表示一个字符串。根节点为空：Trie树的根节点通常为空，用来表示整个树的开始。子节点指向可能的下一个字符：每个节点的子节点表示可能的下一个字符，从而形成字符串。
前缀树学习
hxxx1314的博客
12-15 1419
替换单词 在英语中，有一个叫做 词根(root) 的概念，它可以跟着其他一些词组成另一个较长的单词——我们称这个词为 继承词(successor)。例如，词根an，跟随着单词 other(其他)，可以形成新的单词 another(另一个)。现在，给定一个由许多词根组成的词典和一个句子，需要将句子中的所有继承词用词根替换掉。如果继承词有许多可以形成它的词根，则用最短的词根替换它。需要输出替换之后的句子。 示例 1： 输入：dictionary = [“cat”,“bat”,“rat”], sentence =
Trie树实现
x_i_y_u_e的专栏
05-03 745
用Java实现一个Trie树，trie，又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。一个节点的所有子孙都有相同的前缀，也就是这个节点对应的字符串，而根节点对应空字符串。一般情况下，不是所有的节点都有对应的值，只有叶子节点和部分内部节点所对应的键才有相关的值。 更多关于Trie的介绍可以查看维基百科T
Trie树的Java实现
sh_c1991的专栏
03-12 2124
第一部分、Trie树 1.1、什么是Trie树     Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。     Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到
字典树（前缀树）
业精于勤，荒于嬉；行成于思，毁于随。
12-22 416
字典树==前缀树==Trie树： 查询某个单词（前缀）在所有单词中出现次数的一种数据结构 查询和插入时间复杂度都是O(n)，是一种以空间换时间的方法。 （字典树） 字典树基本模板： [cpp] view plaincopy #define  MAX    26 //字符集大小    typedef struct TrieNode  {      int
IT笔试面试--Trie树前缀树常考题目及解析
04-14
Trie树，又称字典树或前缀树，是一种用于快速检索的多叉树结构，广泛应用于字符串处理领域。它能有效地利用字符串的公共前缀来减少存储空间，并在查询、插入和删除等方面具有较高的效率。 #### Trie树基本特性 - *...
Python算法题源代码-LeetCode(力扣)-实现 Trie (前缀树)
02-25
实现 Trie (前缀树) Trie（发音类似 "try"）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。 这一数据结构有相当多的应用情景，例如自动补完和拼写检查。 请你实现 Trie 类： Trie()...
trie树的实现（C）
05-18
trie.c中定义了trie树的操作函数； trie.h为相应的头文件； test.c用于测试相关的函数。 在trie.c中，关于查找定义了两个函数，一个是find()，一个是search()，二者的区别是，前者仅判断一个字符串是否在树中出现，而后者除了判断字符串是否出现，还会判断待查找的字符串是否是一个合法的单词。
php-leetcode题解之实现Trie前缀树.zip
06-11
6. **实际应用**：Trie树在很多场景下都有广泛应用，如自动补全、关键词过滤、IP路由等。在LeetCode上，这个问题旨在测试对数据结构的理解以及在PHP中实现高效算法的能力。 通过这个压缩包，你可以找到详细的PHP...
Trie树_字典树(字符串排序)简介及实现
10-26
在实现Trie树时，通常会定义一个Trie节点结构，该结构包含一个布尔值标记（记录此处是否构成一个串），以及一个指针数组（指向各个子树的指针）。在实现代码中，通常会声明一个常量branchNum来表示分支的数量，此处...
【字典树/前缀树】Trie树的应用与实现（图解）
Guyui233的博客
05-25 597
一、Trie树 Trie树又叫字典树、前缀树、单次查找树，是一种多叉树结构，如下图所示 Trie树的基本性质 1.根节点不包含字符，除根节点外的每一个子节点都包含一个字符。 2.从根节点到某一个节点，路径上经过的字符连接起来，为该节点对应的字符串。 3.每个节点的所有子节点包含的字符互不相同。 Trie树的优点 1.插入和查询的效率很高，都为O(m)，其中m是待插入/查询的字符串的长度。 2.Trie树中不同的关键字不会产生冲突 3.Trie树只有再允许一个关键字关联多个值的情况下才有类似hash碰撞产
Trie树的实现
naturerun的博客
12-03 497
Trie树是保存字符串公共前缀信息的数据结构,可用于字符串多模匹配，普通的非压缩Trie树实现如下 第一种实现:每个分支节点使用map标准库容器保存前缀索引 #include <map> #include <stack> #include <vector> #include <string> #include <iostream> #include <random> using namespace std; enum Compa
oracle 查询表里信息_Oracle 查询库中所有表信息
weixin_39618824的博客
12-19 400
Oracle 查询库中所有表信息查询所有表名：select t.table_name from user_tables t;查询所有字段名：select t.column_name from user_col_comments t;查询指定表的所有字段名：select t.column_name from user_col_comments t where t.table_name = "BIZ_...
Trie树（字典树）
weixin_30629653的博客
10-16 566
1. Trie树 Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。 Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。 它有3个基本性质： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱跑步的程序员~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值