前缀树算法模板

最新推荐文章于 2024-08-04 16:58:42 发布
最新推荐文章于 2024-08-04 16:58:42 发布
阅读量291 收藏
点赞数
分类专栏： 刷题 文章标签： 算法 java 数据结构
原文链接：https://mp.weixin.qq.com/s/hGrTUmM1zusPZZ0nA9aaNw
版权

文章目录


Trie 树又叫字典树、前缀树、单词查找树，是一种二叉树衍生出来的高级数据结构，主要应用场景是处理字符串前缀相关的操作。

关于Map和Set，是两个抽象数据结构（接口），Map存储一个键值对集合，其中键不重复，Set存储一个不重复的元素集合。

常见的Map和Set的底层实现原理有哈希表和二叉搜索树两种，比如 Java 的 HashMap/HashSet 和 C++ 的 unorderd_map/unordered_set 底层就是用哈希表实现，而 Java 的 TreeMap/TreeSet 和 C++ 的 map/set 底层使用红黑树这种自平衡 BST 实现的。

而本文实现的 TrieSet/TrieMap 底层则用 Trie 树这种结构来实现。

了解数据结构的读者应该知道，本质上Set可以视为一种特殊的Map，Set其实就是Map中的键。

所以本文先实现TrieMap，然后在TrieMap的基础上封装出TrieSet。

Trie 树原理

Trie 树本质上就是一棵从二叉树衍生出来的多叉树。

二叉树节点的代码实现是这样：

/* 基本的二叉树节点 */
class TreeNode {
    int val;
    TreeNode left, right;
}

其中left, right存储左右子节点的指针，所以二叉树的结构是这样：
在这里插入图片描述
多叉树节点的代码实现是这样：

/* 基本的多叉树节点 */
class TreeNode {
    int val;
    TreeNode[] children;
}

其中children数组中存储指向孩子节点的指针，所以多叉树的结构是这样：
在这里插入图片描述
而TrieMap中的树节点TrieNode的代码实现是这样：

/* Trie 树节点实现 */
class TrieNode<V> {
    V val = null;
    TrieNode<V>[] children = new TrieNode[256];
}

这个val字段存储键对应的值，children数组存储指向子节点的指针。

但是和之前的普通多叉树节点不同，TrieNode中children数组的索引是有意义的，代表键中的一个字符。

比如说children[97]如果非空，说明这里存储了一个字符'a'，因为'a'的 ASCII 码为 97。

我们的模板只考虑处理 ASCII 字符，所以children数组的大小设置为 256。不过这个可以根据具体问题修改，比如改成更小的数组或者HashMap<Character, TrieNode>都是一样的效果。

有了以上铺垫，Trie 树的结构是这样的：

在这里插入图片描述
一个节点有 256 个子节点指针，但大多数时候都是空的，可以省略掉不画，所以一般你看到的 Trie 树长这样：
在这里插入图片描述
这是在TrieMap<Integer>中插入一些键值对后的样子，白色节点代表val字段为空，橙色节点代表val字段非空。

这里要特别注意，TrieNode节点本身只存储val字段，并没有一个字段来存储字符，字符是通过子节点在父节点的children数组中的索引确定的。

形象理解就是，Trie 树用「树枝」存储字符串（键），用「节点」存储字符串（键）对应的数据（值）。所以我在图中把字符标在树枝，键对应的值val标在节点上：

TrieMap/TrieSet API 及实现

API

// 底层用 Trie 树实现的键值映射
// 键为 String 类型，值为类型 V
class TrieMap<V> {

    /***** 增/改 *****/

    // 在 Map 中添加 key
    public void put(String key, V val);

    /***** 删 *****/

    // 删除键 key 以及对应的值
    public void remove(String key);

    /***** 查 *****/

    // 搜索 key 对应的值，不存在则返回 null
    // get("the") -> 4
    // get("tha") -> null
    public V get(String key);

    // 判断 key 是否存在在 Map 中
    // containsKey("tea") -> false
    // containsKey("team") -> true
    public boolean containsKey(String key);

    // 在 Map 的所有键中搜索 query 的最短前缀
    // shortestPrefixOf("themxyz") -> "the"
    public String shortestPrefixOf(String query);

    // 在 Map 的所有键中搜索 query 的最长前缀
    // longestPrefixOf("themxyz") -> "them"
    public String longestPrefixOf(String query);

    // 搜索所有前缀为 prefix 的键
    // keysWithPrefix("th") -> ["that", "the", "them"]
    public List<String> keysWithPrefix(String prefix);

    // 判断是和否存在前缀为 prefix 的键
    // hasKeyWithPrefix("tha") -> true
    // hasKeyWithPrefix("apple") -> false
    public boolean hasKeyWithPrefix(String prefix);

    // 通配符 . 匹配任意字符，搜索所有匹配的键
    // keysWithPattern("t.a.") -> ["team", "that"]
    public List<String> keysWithPattern(String pattern);

    // 通配符 . 匹配任意字符，判断是否存在匹配的键
    // hasKeyWithPattern(".ip") -> true
    // hasKeyWithPattern(".i") -> false
    public boolean hasKeyWithPattern(String pattern);

    // 返回 Map 中键值对的数量
    public int size();
}

实现：

class TrieMap<V> {
    // ASCII 码个数
    private static final int R = 256;
    // 当前存在 Map 中的键值对个数
    private int size = 0;
    // Trie 树的根节点
    private TrieNode<V> root = null;

    private static class TrieNode<V> {
        V val = null;
        TrieNode<V>[] children = new TrieNode[R];
    }

    /***** 增/改 *****/

    // 在 map 中添加或修改键值对
    public void put(String key, V val) {
        if (!containsKey(key)) {
            // 新增键值对
            size++;
        }
        // 需要一个额外的辅助函数，并接收其返回值
        root = put(root, key, val, 0);
    }

    // 定义：向以 node 为根的 Trie 树中插入 key[i..]，返回插入完成后的根节点
    private TrieNode<V> put(TrieNode<V> node, String key, V val, int i) {
        if (node == null) {
            // 如果树枝不存在，新建
            node = new TrieNode<>();
        }
        if (i == key.length()) {
            // key 的路径已插入完成，将值 val 存入节点
            node.val = val;
            return node;
        }
        char c = key.charAt(i);
        // 递归插入子节点，并接收返回值
        node.children[c] = put(node.children[c], key, val, i + 1);
        return node;
    }

    /***** 删 *****/

    // 在 Map 中删除 key
    public void remove(String key) {
        if (!containsKey(key)) {
            return;
        }
        // 递归修改数据结构要接收函数的返回值
        root = remove(root, key, 0);
        size--;
    }

    // 定义：在以 node 为根的 Trie 树中删除 key[i..]，返回删除后的根节点
    private TrieNode<V> remove(TrieNode<V> node, String key, int i) {
        if (node == null) {
            return null;
        }
        if (i == key.length()) {
            // 找到了 key 对应的 TrieNode，删除 val
            node.val = null;
        } else {
            char c = key.charAt(i);
            // 递归去子树进行删除
            node.children[c] = remove(node.children[c], key, i + 1);
        }
        // 后序位置，递归路径上的节点可能需要被清理
        if (node.val != null) {
            // 如果该 TireNode 存储着 val，不需要被清理
            return node;
        }
        // 检查该 TrieNode 是否还有后缀
        for (int c = 0; c < R; c++) {
            if (node.children[c] != null) {
                // 只要存在一个子节点（后缀树枝），就不需要被清理
                return node;
            }
        }
        // 既没有存储 val，也没有后缀树枝，则该节点需要被清理
        return null;
    }

    /***** 查 *****/

    // 搜索 key 对应的值，不存在则返回 null
    public V get(String key) {
        // 从 root 开始搜索 key
        TrieNode<V> x = getNode(root, key);
        if (x == null || x.val == null) {
            // x 为空或 x 的 val 字段为空都说明 key 没有对应的值
            return null;
        }
        return x.val;
    }

    // 判断 key 是否存在在 Map 中
    public boolean containsKey(String key) {
        return get(key) != null;
    }

    // 判断是和否存在前缀为 prefix 的键
    public boolean hasKeyWithPrefix(String prefix) {
        // 只要能找到一个节点，就是存在前缀
        return getNode(root, prefix) != null;
    }

    // 在所有键中寻找 query 的最短前缀
    public String shortestPrefixOf(String query) {
        TrieNode<V> p = root;
        // 从节点 node 开始搜索 key
        for (int i = 0; i < query.length(); i++) {
            if (p == null) {
                // 无法向下搜索
                return "";
            }
            if (p.val != null) {
                // 找到一个键是 query 的前缀
                return query.substring(0, i);
            }
            // 向下搜索
            char c = query.charAt(i);
            p = p.children[c];
        }

        if (p != null && p.val != null) {
            // 如果 query 本身就是一个键
            return query;
        }
        return "";
    }

    // 在所有键中寻找 query 的最长前缀
    public String longestPrefixOf(String query) {
        TrieNode<V> p = root;
        // 记录前缀的最大长度
        int max_len = 0;

        // 从节点 node 开始搜索 key
        for (int i = 0; i < query.length(); i++) {
            if (p == null) {
                // 无法向下搜索
                break;
            }
            if (p.val != null) {
                // 找到一个键是 query 的前缀，更新前缀的最大长度
                max_len = i;
            }
            // 向下搜索
            char c = query.charAt(i);
            p = p.children[c];
        }

        if (p != null && p.val != null) {
            // 如果 query 本身就是一个键
            return query;
        }
        return query.substring(0, max_len);
    }

    // 搜索前缀为 prefix 的所有键
    public List<String> keysWithPrefix(String prefix) {
        List<String> res = new LinkedList<>();
        // 找到匹配 prefix 在 Trie 树中的那个节点
        TrieNode<V> x = getNode(root, prefix);
        if (x == null) {
            return res;
        }
        // DFS 遍历以 x 为根的这棵 Trie 树
        traverse(x, new StringBuilder(prefix), res);
        return res;
    }

    // 遍历以 node 节点为根的 Trie 树，找到所有键
    private void traverse(TrieNode<V> node, StringBuilder path, List<String> res) {
        if (node == null) {
            // 到达 Trie 树底部叶子结点
            return;
        }

        if (node.val != null) {
            // 找到一个 key，添加到结果列表中
            res.add(path.toString());
        }

        // 回溯算法遍历框架
        for (char c = 0; c < R; c++) {
            // 做选择
            path.append(c);
            traverse(node.children[c], path, res);
            // 撤销选择
            path.deleteCharAt(path.length() - 1);
        }
    }

    // 通配符 . 匹配任意字符
    public List<String> keysWithPattern(String pattern) {
        List<String> res = new LinkedList<>();
        traverse(root, new StringBuilder(), pattern, 0, res);
        return res;
    }

    // 遍历函数，尝试在「以 node 为根的 Trie 树中」匹配 pattern[i..]
    private void traverse(TrieNode<V> node, StringBuilder path, String pattern, int i, List<String> res) {
        if (node == null) {
            // 树枝不存在，即匹配失败
            return;
        }
        if (i == pattern.length()) {
            // pattern 匹配完成
            if (node.val != null) {
                // 如果这个节点存储着 val，则找到一个匹配的键
                res.add(path.toString());
            }
            return;
        }
        char c = pattern.charAt(i);
        if (c == '.') {
            // pattern[i] 是通配符，可以变化成任意字符
            // 多叉树（回溯算法）遍历框架
            for (char j = 0; j < R; j++) {
                path.append(j);
                traverse(node.children[j], path, pattern, i + 1, res);
                path.deleteCharAt(path.length() - 1);
            }
        } else {
            // pattern[i] 是普通字符 c
            path.append(c);
            traverse(node.children[c], path, pattern, i + 1, res);
            path.deleteCharAt(path.length() - 1);
        }
    }

    // 判断是和否存在前缀为 prefix 的键
    public boolean hasKeyWithPattern(String pattern) {
        // 从 root 节点开始匹配 pattern[0..]
        return hasKeyWithPattern(root, pattern, 0);
    }

    // 函数定义：从 node 节点开始匹配 pattern[i..]，返回是否成功匹配
    private boolean hasKeyWithPattern(TrieNode<V> node, String pattern, int i) {
        if (node == null) {
            // 树枝不存在，即匹配失败
            return false;
        }
        if (i == pattern.length()) {
            // 模式串走到头了，看看匹配到的是否是一个键
            return node.val != null;
        }
        char c = pattern.charAt(i);
        // 没有遇到通配符
        if (c != '.') {
            // 从 node.children[c] 节点开始匹配 pattern[i+1..]
            return hasKeyWithPattern(node.children[c], pattern, i + 1);
        }
        // 遇到通配符
        for (int j = 0; j < R; j++) {
            // pattern[i] 可以变化成任意字符，尝试所有可能，只要遇到一个匹配成功就返回
            if (hasKeyWithPattern(node.children[j], pattern, i + 1)) {
                return true;
            }
        }
        // 都没有匹配
        return false;
    }

    // 从节点 node 开始搜索 key，如果存在返回对应节点，否则返回 null
    private TrieNode<V> getNode(TrieNode<V> node, String key) {
        TrieNode<V> p = node;
        // 从节点 node 开始搜索 key
        for (int i = 0; i < key.length(); i++) {
            if (p == null) {
                // 无法向下搜索
                return null;
            }
            // 向下搜索
            char c = key.charAt(i);
            p = p.children[c];
        }
        return p;
    }

    public int size() {
        return size;
    }
}

Set实现

class TrieSet {
    // 底层用一个 TrieMap，键就是 TrieSet，值仅仅起到占位的作用
    // 值的类型可以随便设置，我参考 Java 标准库设置成 Object
    private final TrieMap<Object> map = new TrieMap<>();

    /***** 增 *****/

    // 在集合中添加元素 key
    public void add(String key) {
        map.put(key, new Object());
    }

    /***** 删 *****/

    // 从集合中删除元素 key
    public void remove(String key) {
        map.remove(key);
    }

    /***** 查 *****/

    // 判断元素 key 是否存在集合中
    public boolean contains(String key) {
        return map.containsKey(key);
    }

    // 在集合中寻找 query 的最短前缀
    public String shortestPrefixOf(String query) {
        return map.shortestPrefixOf(query);
    }

    // 在集合中寻找 query 的最长前缀
    public String longestPrefixOf(String query) {
        return map.longestPrefixOf(query);
    }

    // 在集合中搜索前缀为 prefix 的所有元素
    public List<String> keysWithPrefix(String prefix) {
        return map.keysWithPrefix(prefix);
    }

    // 判断集合中是否存在前缀为 prefix 的元素
    public boolean hasKeyWithPrefix(String prefix) {
        return map.hasKeyWithPrefix(prefix);
    }

    // 通配符 . 匹配任意字符，返回集合中匹配 pattern 的所有元素
    public List<String> keysWithPattern(String pattern) {
        return map.keysWithPattern(pattern);
    }

    // 通配符 . 匹配任意字符，判断集合中是否存在匹配 pattern 的元素
    public boolean hasKeyWithPattern(String pattern) {
        return map.hasKeyWithPattern(pattern);
    }

    // 返回集合中元素的个数
    public int size() {
        return map.size();
    }
}
Joey Liao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
模式匹配之-多模匹配 下篇（AC算法之前缀树实现）
04-22
【模式匹配】之——多模匹配 下篇（AC算法之前缀树实现），对应文章地址： http://blog.csdn.net/sun2043430/article/details/8832496
C++前缀树 字典树 TrieTree的学习与模拟实现
wtl666_6的博客
01-25 6712
前缀树 字典树 TrieTree的学习与模拟实现
算法【前缀树】
最新发布
W_O_Z的博客
08-04 1003
注意：学习本篇最少应知道什么是树结构和哈希表怎么用。前缀树又叫字典树，英文名trie。每个样本 都从头节点开始 根据 前缀字符或者前缀数字 建出来的一棵大树，就是前缀树。没有路就新建节点；已经有路了，就复用节点。前缀树的使用场景：需要根据前缀信息来查询的场景前缀树的优点：根据前缀信息选择树上的分支，可以节省大量的时间前缀树的缺点：比较浪费空间，和总字符数量有关，字符的种类有关。
【算法模板】前缀树（原理+数组&哈希实现）
kangjielearning的博客
04-17 687
前缀树 前缀是原理 前缀树是N叉树的一种特殊形式，通常来用来存储字符串。 前缀树每一个节点代表一个字符串（前缀），每个节点会有多个子节点，通往不同子节点的路径上有着不同的字符。 子节点代表的字符串是由节点本身的原始字符串，以及通往该子节点路径上所有的字符组成的。 根节点表示空字符串。 重要特性：节点所有的后代都与该节点相关的字符串有着共同的前缀。 前缀树的特别之处在于字符和子节点之间的对应关系。 可用于用于自动补全、拼写检查。 前缀树表示方法 用数组存储子节点 #define N 26 // 2
C++实现前缀树
学代码的咸鱼的博客
04-11 887
C++详细实现前缀树！
C++图解前缀树（字典树）
强者之路
07-16 1118
今天看到了最长公共前缀树的时候就突然想到了前几个星期学的前缀树。所以打算来写写。 试想有这样一种场景，我们现在手里有10W个单词，并且里面有重复的单词，如果我们使用传统的遍历手法查找一个单词，那么可能没等查出来交卷铃声已经响了。 或许有人会说使用哈希表，但是存在重复的单词，这个效率还是欠缺了点。 所以就引入了今天的主角—字典树。 字典树又称之为前缀树，是一个哈希表的变种，优于哈希表的查找速度。但是他的空间复杂度是十分复杂的，所以是一种空间换时间的做法。 ...
acm 算法 字典树模板
05-29
ACM 算法字典树模板 在算法竞赛中，字典树（Trie）是一种常用的数据结构，用于解决字符串匹配问题。下面是字典树的基本概念和实现细节。 字典树的基本概念 字典树是一种树形数据结构，用于存储字符串集合。它的每...
算法模板1
08-03
以下是一些常见的算法模板及其应用： 1. **时间复杂度**：理解算法的时间复杂度是优化代码的关键。例如，快速排序的平均时间复杂度为O(n log n)，最坏情况为O(n^2)，而归并排序始终保持O(n log n)。 2. **排序**：...
蓝桥杯Python组算法模板大全
04-04
在本节中，我们将针对蓝桥杯Python组算法模板进行深入探讨，从基础排序算法到更高级的算法概念，如动态规划、图论、字符串处理和数论等。所有这些内容都是使用Python语言进行实现的，对Python程序员来说，掌握这些...
ACM 算法模板集
04-19
ACM 算法模板集 Contents 一. 常用函数与STL 二. 重要公式与定理 1. Fibonacci Number 2. Lucas Number 3. Catalan Number 4. Stirling Number(Second Kind) 5. Bell Number 6. Stirling's Approximation 7. Sum of ...
部分常见算法模板总结
01-09
算法模板是编程中解决问题的一种标准化方法，它们是一组定义好的、在特定问题上效率较高的算法流程。本知识点总结了部分常见的算法模板，包括高精计算、快速幂、背包问题、区间DP、并查集、树状结构等。下面将详细...
treebitmap:IPv4IPv6前缀的快速IP查找表
05-06
树位图：IPv4 / IPv6前缀的快速查找表 此板条箱提供了用于快速IP地址查找的数据结构。 它旨在快速查找时间和合理的内存占用量。 内部数据结构基于W.Eatherton，Z.Dittia，G.Varghes描述的树位图算法。 文献资料 Rustdoc： ：//docs.rs/treebitmap/ 插图 代表包含一个路由表中的字典树的示例图示0.0.0.0/0 （富）， 10.0.0.0/8 （巴）， 172.16.0.0/12 （巴兹）和192.168.0.0/16 （QUUX）。 内部Trie数据结构基础 Node在位图中对结果和子节点指针进行编码。 一个Trie节点充当“端节点”时最多可以编码31个结果，或者当充当普通/内部节点时可以编码15个结果和16个子/子树。 位图中的每个位指示一个位匹配模式： 少量 0 1个 2个 3 4 5 6 7 比赛 *
TreeSet详解
lxzGood的博客
06-23 2万+
TreeSet需要掌握的知识点
使用Trie树实现的MAP
cjf_wei的博客
12-10 1772
最近看到一种基于Tire树的map结构，其键值类型为string类型，查找速度很快。文章[1]中分析了这种‘TrieMap’原理，对比了其和std::map，std::unordered_map的查找速度。基于Trie树和文章中提到的TrieMap设计，进行实践，给出自己构造的TrieMap以供参考学习。Trie树，又称单词查找树、字典树。是一种哈希树的变种，是一种用于快速检索的多叉树结构。
【数据结构与算法】【12】前缀表达式、中缀表达式、后缀表达式
天天向上 Up Up Up (*^▽^*)
06-06 1万+
什么是前缀表达式、中缀表达式、后缀表达式前缀表达式、中缀表达式、后缀表达式，是通过树来存储和计算表达式的三种不同方式以如下公式为例(a+(b−c))∗d( a+(b-c) )*d(a+(b−c))∗d通过树来存储该公式，可以表示为 那么问题就来了，树只是一种抽象的数据结构，它必须要通过某个形式的文本来才能存储和输入此时，就有了三种表示方法：前缀表达式、中缀表达式、后缀表达式它们分别相当于树的前序遍历、中序遍历、后序遍历，前中后指的是遍历时符号的遍历顺序前序遍历：符号 - 左操作数 - 右操作数中序遍历：左操
树：表达式树与前中后缀表达式
qfturauyls的博客
07-16 1721
计算机科学中，除了栈以外，二叉树也是处理表达式的常用工具，为了处理表达式而遵循相应规则构造的树被称为表达式树 表达式树： 算数表达式是分层的递归结构，一个运算符作用于相应的运算对象，其运算对象又可以是任意复杂的表达式。树的递归结构正好用来表示这种表达式。下面只讨论二元表达式。二元表达式可以很自然的联系到二叉树：以基本运算对象作为叶节点中的数据；以运算符作为非叶节点中的数据，其两棵子树是它的运算对象，子树可以是基本运算对象，也可以是复杂表达式。如图是一个表达式树。 前缀...
Trie树详解及其应用
热门推荐
Hackbuteer1的专栏
09-10 7万+
一、知识简介         最近在看字符串算法了，其中字典树、AC自动机和后缀树的应用是最广泛的了，下面将会重点介绍下这几个算法的应用。       字典树（Trie）可以保存一些字符串->值的对应关系。基本上，它跟 Java 的 HashMap 功能相同，都是 key-value 映射，只不过 Trie 的 key 只能是字符串。 　　Trie 的强大之处就在于它的时间复杂度。它的插入和
高级数据结构1—初识树状数组—快速求得前缀和和修改某一元素值
CS_boy的博客
04-04 825
树状数组的原理与模板
算法 - 前缀树
weixin_40459875的博客
08-11 1826
目录 一、前缀树含义 二、代码实现 （一）前缀树实现 方式一： 方式二： （二）暴力实现 一、前缀树含义 前缀树：把一个“最小”单位的数据看成一个节点到另一个节点的路径，每个节点有两个属性，一个是所有数据经过这个节点的次数pass，一个是这个节点作为结束位置的次数end。 例如，一个数组["abc","abd","ab","kst"]，看它怎么用前缀树表示： （1）首先有一个节点，指向null （2）看"abc"，怎么生成前缀树 a.首先是a，第一个节点没有a路径，先生成a.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值