13.Trie树的基本实现与特性

最新推荐文章于 2023-05-10 23:35:46 发布
最新推荐文章于 2023-05-10 23:35:46 发布
阅读量344 收藏 1
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/org_hjh/article/details/107879112
版权

13.Trie树的基本实现与特性

理解字典树之前我们先提出三个问题，后面我们再来回答：

  1. 字典树的数据结构
  2. 字典树的核心思想
  3. 字典树的基本性质

本文是之前的《字典树实现》的一个升级，如果觉得本篇稍繁杂可以去看之前的一篇。

在这里我们也先回忆一下树，树本身定义比较简单，如下图：

如果你看到上图这样的一个层级，你应该马上会想到按层次来打印一颗二叉树，这个题目是非常高频的题目：
102. 二叉树的层序遍历。
那么这里你不记得这个题目或者对写这个代码的话还有一点模糊，你可以去再练习一遍。

同时深度优先搜索和广度优先搜索你应该也需要掌握。这里可以看一下我之前的一遍文章：深度优先搜索和广度优先搜索

二叉搜索树
一提到二叉搜索树你就应该想到是子树的关系，并不是儿子和父亲的关系。那么它的定义就说：任何一个结点，所有的左子树值都比根节点小，所有的右子树值都比根节点大，且对于它的任何子树同样地以此类推。对于任何子树都满足这样的特性，这个就是所谓的二叉搜索树。

另外一个特性：二叉搜索树是一个升序的序列，如果是中序遍历的话（左-根-右）。

那么还有一种情况，在现实中特别常见，但是在二叉搜索树来进行存储的话并不是特别好解决这样的一个实际问题。就是在搜索的时候，当你打来一个字母的前缀或者你中文也类似，比如说你打来一个周杰，一般人可能会觉得是伦，就是周杰伦。同理英文的话就是you的话就有这么多可以感应出来的，像这种所谓的词频的感应或者是由前缀来推后面可能的词语。那么它应该用怎样的数据结构来表示？

字典树（Trie）

1. 基本结构

字典树，即 Tire 树，又称单词查找树或键树，是一种树型结构。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。

它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希高。其核心思想是利用公共前缀来减少查询实际。

2. 基本性质

  1. 结点本身不存完整单词；
  2. 从根结点到某一结点，路径上经过的字符连接起来，为该结点对应的字符串；
  3. 每个结点的所有子结点路径代表的字符都不相同。

结点存储额外信息

很多时候我们还要统计频次，应该怎么做呢？就会在这里加一个数字，所以这个数字就表示相应到这个结点所代表的单词它的统计的计数就放在这个地方，当然来它的结点上可以存其他的额外的信息，在这个图上只是用数字来举例。这里数字就是这个单词出现的统计频次。而按照统计频次，我们后序就可以给用户做相应的推荐。

结点的内部实现

每个结点的如果是英文的话，那么毫无疑问它就会存到下一个结点去的话，指向下一个结点的不同的指针，这里它存储就不再是用left 和 right 来表示左右结点来，它就直接用相应的字符来指向下一个结点。同时除了小写的 abcdefg... 还有大写的 ABCDEFG... ，同时如果还存在一些特殊符合的话，也可以放这里，所以如果是简单单词的话，同时不分大小写，你可以认为这里是26个分叉，就从 a 分到 z 26个分叉出去，当然你如果要包含大小写或者包括其他的话就更多，同时如果是整个字符串的话，它的 ASCII 域是255，所以是255分叉。一般来说你可以认为是26分叉的一个多叉树。

3. 核心思想

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

实战题目

208. 实现 Trie (前缀树)

212. 单词搜索 II

208. 实现 Trie (前缀树)

Trie 树代码模板

//Java
class Trie {
    private boolean isEnd;
    private Trie[] next;
    /** Initialize your data structure here. */
    public Trie() {
        isEnd = false;
        next = new Trie[26];
    }
    
    /** Inserts a word into the trie. */
    public void insert(String word) {
        if (word == null || word.length() == 0) return;
        Trie curr = this;
        char[] words = word.toCharArray();
        for (int i = 0;i < words.length;i++) {
            int n = words[i] - 'a';
            if (curr.next[n] == null) curr.next[n] = new Trie();
            curr = curr.next[n];
        }
        curr.isEnd = true;
    }
    
    /** Returns if the word is in the trie. */
    public boolean search(String word) {
        Trie node = searchPrefix(word);
        return node != null && node.isEnd;
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    public boolean startsWith(String prefix) {
        Trie node = searchPrefix(prefix);
        return node != null;
    }

    private Trie searchPrefix(String word) {
        Trie node = this;
        char[] words = word.toCharArray();
        for (int i = 0;i < words.length;i++) {
            node = node.next[words[i] - 'a'];
            if (node == null) return null;
        }
        return node;
    }
}

# Python 
class Trie(object):
  
	def __init__(self): 
		self.root = {} 
		self.end_of_word = "#" 
 
	def insert(self, word): 
		node = self.root 
		for char in word: 
			node = node.setdefault(char, {}) 
		node[self.end_of_word] = self.end_of_word 
 
	def search(self, word): 
		node = self.root 
		for char in word: 
			if char not in node: 
				return False 
			node = node[char] 
		return self.end_of_word in node 
 
	def startsWith(self, prefix): 
		node = self.root 
		for char in prefix: 
			if char not in node: 
				return False 
			node = node[char] 
		return True

//C/C++
class Trie {
    struct TrieNode {
        map<char, TrieNode*>child_table;
        int end;
        TrieNode(): end(0) {}
    };
        
public:
    /** Initialize your data structure here. */
    Trie() {
        root = new TrieNode();
    }
    
    /** Inserts a word into the trie. */
    void insert(string word) {
        TrieNode *curr = root;
        for (int i = 0; i < word.size(); i++) {
            if (curr->child_table.count(word[i]) == 0)
                curr->child_table[word[i]] = new TrieNode();
                
            curr = curr->child_table[word[i]];                
        }
        curr->end = 1;
    }
    
    /** Returns if the word is in the trie. */
    bool search(string word) {
        return find(word, 1);
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    bool startsWith(string prefix) {
        return find(prefix, 0);
    }
private:
    TrieNode* root;
    bool find(string s, int exact_match) {
        TrieNode *curr = root;
        for (int i = 0; i < s.size(); i++) {
            if (curr->child_table.count(s[i]) == 0)
                return false;
            else
                curr = curr->child_table[s[i]];
        }
        
        if (exact_match)
            return (curr->end) ? true : false;
        else
            return true;
    }
};

// JavaScript
class Trie {
  constructor() {
    this.root = {};
    this.endOfWord = "$";
  }

  insert(word) {
    let node = this.root;
    for (let ch of word) {
      node[ch] = node[ch] || {};
      node = node[ch];
    }
    node[this.endOfWord] = this.endOfWord;
  }

  search(word) {
    let node = this.root;
    for (let ch of word) {
      if (!node[ch]) return false;
      node = node[ch];
    }
    return node[this.endOfWord] === this.endOfWord;
  }

  startsWith(word) {
    let node = this.root;
    for (let ch of word) {
      if (!node[ch]) return false;
      node = node[ch];
    }
    return true;
  }
}


let trie = new Trie();
console.log(trie.insert("apple"));
console.log(trie.search("apple")); // 返回 true
console.log(trie.search("app")); // 返回 false
console.log(trie.startsWith("app")); // 返回 true
console.log(trie.insert("app"));
console.log(trie.search("app")); // 返回 true

212. 单词搜索 II

class Solution {
    public List<String> findWords(char[][] board, String[] words) {
        // 构建字典树
        Trie trie = new Trie();
        // 插入数据
        for (String word : words) {
            trie.insert(word);
        }

        // 构建结果集容器
        List<String> result = new LinkedList<>();
        // 矩阵行数
        int m = board.length;
        // 矩阵列数
        int n = board[0].length;
        // 存储该结点是否访问
        boolean[][] visited = new boolean[m][n];
        // 遍历整个二维数组
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                find(board, visited, i, j, m, n, result, trie);
            }
        }
        return result;
    }

    private void find(char[][] board, boolean[][] visited, int i, int j, int m, int n, List<String> result, Trie cur) {
        // 边界判断以及是否已经访问判断
        if (i < 0 || i >= m || j < 0 || j >=n || visited[i][j]) {
            return;
        }
        // 获取子结点状态，判断其是否又子结点
        cur = cur.next[board[i][j] - 'a'];
        if (cur == null) return;

        // 修改结点状态，防止重复访问
        visited[i][j] = true;
        // 找到单词加入
        if (cur.isEnd) {
            result.add(cur.val);
            // 找到单词后，修改字典树内叶子结点状态为false，防止出现重复单词
            cur.isEnd = false;
        }
        find(board, visited, i + 1, j, m, n, result, cur);
        find(board, visited, i - 1, j, m, n, result, cur);
        find(board, visited, i, j + 1, m, n, result, cur);
        find(board, visited, i, j - 1, m, n, result, cur);
        // 最后修改结点状态为未访问状态
        visited[i][j] = false;
    }

    class Trie {
        // 表示是否最后叶子结点
        private boolean isEnd;
        // 表示字节的
        private Trie[] next;
        // 存储最后结点的字符串
        private String val;

        public Trie() {
            isEnd = false;
            next = new Trie[26];
        }
        
        public void insert(String word) {
            if (word == null || word.length() == 0) return;
            Trie curr = this;
            char[] words = word.toCharArray();
            for (int i = 0; i < words.length; i++) {
                // 判断是否存在该字符的结点，不存在则创建
                int n = words[i] - 'a';
                if (curr.next[n] == null) {
                    curr.next[n] = new Trie();
                }
                curr = curr.next[n];
            }
            // 遍历结束后，修改叶子结点的状态，并存储字符串
            curr.isEnd = true;
            curr.val = word;
        }

        public boolean search(String word) {
            Trie node = searchPrefix(word);
            return node != null && node.isEnd;
        }

        public boolean startsWith(String prefix) {
            Trie node = searchPrefix(prefix);
            return node != null;
        }

        private Trie searchPrefix(String word) {
            Trie node = this;
            char[] words = word.toCharArray();
            for (int i = 0; i < words.length; i++) {
                node = node.next[words[i] - 'a'];
                if (node == null) return null;
            }
            return node;
        }
    }
}


部分图片来源于网络，版权归原作者，侵删。
一角钱技术
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字典树trie详解
alias
04-02 1061
trie 简介 在计算机科学中，trie，又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。一个节点的所有子孙都有相同的前缀，也就是这个节点对应的字符串，而根节点对应空字符串。一般情况下，不是所有的节点都有对应的值，只有叶子节点和部分内部节点所对应的键才有相关的值。 Trie这个术语来自于retrieva...
面试只Trie树特点和应用场景
My World
09-12 2084
Trie树也叫前序表达树（prefix tree），Trie树的结构在这里不再赘述，请参考wiki trie，附一张wiki的图，如下： Trie通常和二叉搜索树作比较，同时也和HashTable做比较，其特点如下： 优点： 1. Trie进行对某个string查找的时间复杂度为O(m)，m为string中字符个数。相比较，BST（二叉搜索树）的时间复杂度是O(logN），在树不平衡
Trie树的实现
warringah的专栏
08-07 851
Trie树的实现 一、定义： Trie，又称字典树，是一种用于快速检索的二十六叉树结构。典型的空间换时间   二、结构图： 三、原理： Trie把要查找的关键词看作一个字符序列，并根据构成关键词字符的先后顺序检索树结构； 特别地：和二叉查找树不同，在Trie树中，每个结点上并非存储一个元素。   四、性质： 0、利用串的公共前缀，节约内存 1、在trie树上进行检
字典树实现_Trie树的基本原理及实现
weixin_42303721的博客
01-02 244
前言在做用户 query 理解的过程中，有许多需要使用词典来"识别"的过程。在此期间，就避免不了使用 Trie 树这一数据结构。因此今天我们来深入的学习一下 Trie 树相关的理论知识，并且动手编码实现。理论知识什么是 Trie 树下面的定义引自维基百科。在计算机科学中，trie，又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而...
字典树的基本知识及使用C语言的相关实现
01-20
概念  如果我们有and,as,at,cn,com这些关键词，那么trie树（字典树... 既然学Trie树，我们肯定要知道这玩意是用来干嘛的。  第一：词频统计。  可能有人要说了，词频统计简单啊，一个hash或者一个堆就可以打完收工
数据结构与算法分析复习资料.doc
05-11
2. **逻辑结构**：逻辑结构是指数据在程序中的抽象表示，包括线性结构（如线性表、栈和队列）、树形结构（如二叉树、堆、Trie树）和图形结构。理解这些逻辑结构有助于设计适合特定问题的数据结构。 3. **物理结构**...
什么是Tire树1
08-08
Trie树有三种基本结构：标准Trie、压缩Trie和后缀Trie。标准Trie是最基础的形式，而压缩Trie通过合并具有相同孩子的节点来减少空间占用。后缀Trie，即后缀树，将在后续的字符串处理主题中详细讨论。 标准Trie树的...
中文分词系统参考实现思路1
08-04
为了使索引结构能够持久化到文件中，需要为二级的Trie树建立一个编号，以便读取时将Trie树快速与Hash表中的项关联起来。然后将Trie树保存到文件中。这类方法在网络上可以找到充分的资料。 三、词典和索引的转化 在...
计算机课程设计全部题目.pdf
最新发布
06-13
【计算机课程设计】\n\n课程设计主要涵盖了四个核心数据结构——Skip List、B-Trees、AVL Tree和N-ary Trie的实现与分析。\n\n1. **Skip List**\nSkip List是一种高效的有序数据结构，通过多层指针跳跃实现快速查找...
Trie树的分析和理解
点缀星辰
01-05 547
简介 　　在使用一些搜索引擎去搜一些东西的时候，我们经常会碰到一个有意思的事情。有时候我们在搜索框输入一部分内容的时候，会发现搜索框会显示一个下拉的列表，里面有一些以前面输入的内容为开头的一系列搜索字段。比如当输入search的时候，搜索框会显示如下的内容： 　　如图所示，这里显示一个比较神奇的东西，网站居然可以给我们有一个自动补全的提示，这样可以省略了一些手动的输入。 那么，是什么可...
Tire-字典树
某科学的程序员
02-18 1589
字典树：一种利用字符串前缀来节省空间的树结构。例如，我需要保存"acm","acca","usb"三个字符串，可以利用"acm"和"acca"的"ac"这个公共前缀节省空间。见下图 树上总有一个根结点，一般不存值，字符从根结点起到叶结点组成 字符串。 代码实现： 1）结点定义：cnt变量是该结点存的值，具体存什么看具体情况。每个结点都有一个指针数组，保存它所指向的结点，数组大小就看字
数据结构之Tire树
靠脑袋是真滴记不住啊！！！！！！！！
05-08 1695
1.0 简介 也叫字典树 又称单词查找树 是一种树形结构，是一种哈希树的变种。 典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串）， 所以经常被搜索引擎系统用于文本词频统计。 它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。...
"trie"（字典树） 和 "异或" 的一些性质
我歌月徘徊，我舞影零乱
08-04 885
目录 异或性质： 没有的性质： 构造完二进制数 后 查找 数字 x 的最大异或： 更进一步的 CodeForces - 1055F Tree and XOR （HDU6625 three arrays ————01 trie + 贪心） 异或性质： 可以求前缀和， 我们想知道a[L] ^ a[L+1] ^ ... ^ a[R] 可以用一个 xor数组记录 ， xor[i] = ...
字典树（Tire树）模板+例题
oliver233的博客
04-14 2390
又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。 将给定的字符串建立为空根数，然后在节点中做相应记录，如到当前前缀串为止的子串。 上面的数就是由字符串 abcd,abd,bc
字典树(Trie树)详解
功不成身已退的博客
05-14 618
字典树(Trie树)  字典树，又称单词查找树，Trie树，是一种树形结构，典型应用是用于统计，排序和保存大量的字符串，所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来节约存储空间，最大限度的减少无谓的字符串比较，查询效率比哈希表高。 它有三个基本性质，根节点不包含字符，除根节点外每一个节点都只包含一个字符，从根节点到某一节点，路径上经过的字符连接起来，为
浅谈trie树（字典树）
一只小蒟蒻的博客
01-26 860
1.关于trie树： 又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高 它的原理是用空间换取时间， 有下面几个特点： 1.根节点不包含字符，除根节点外每一个节点都只包含一个字符。 2...
什么是Trie（字典树），如何优化其性能？
xinyueshikong的博客
05-10 955
Trie 的实现方式有很多种，其中最简单和常见的方法是采用二叉搜索树实现：一个节点具有 O(logn) 的时间复杂度来插入、删除和查找给定长度的字符串。然而，在实际应用中，我们通常需要处理更大的字符串和更复杂的查找条件，这时候可以采用递归遍历的方法实现高效性。二叉搜索树是一种二叉树，其中左子树中所有节点的值都小于根节点的值，右子树中所有节点的值都大于根节点的值。总之，为了优化 Trie（字典树）的性能，我们需要根据实际需求选择合适的数据结构和算法，并采取相应的优化措施来解决问题。
算法学习笔记：Trie 树（字典树）
Plozia 的小窝
01-29 369
算法学习笔记：Trie 树（字典树）1. 概述2. 详解2.1 Trie 树的概念2.2 Trie 树的操作2.2.1 Trie 树的存储 1. 概述 Trie 树，中文名为字典树，是一种字符串的高效处理算法。 Trie 树实现的功能就是快速的查找一堆字符串里面有没有某个串是另一个串的前缀，后缀等等。 2. 详解 2.1 Trie 树的概念 Trie 树首先是一棵树，比如下面这棵树就是一棵 Trie 树。 这棵树是由 ab,abd,ac,bd 四个字符串构成的。 那么结合图示，我们会发现 Trie 树有以
c语言字典trie树代码实现
05-30
以下是一个简单的 C 语言字典 Trie 树的代码实现： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_WORD_LEN 100 typedef struct TrieNode { char value; struct TrieNode *children[26]; int is_end; } TrieNode; TrieNode *createNode(char value) { TrieNode *node = (TrieNode *) malloc(sizeof(TrieNode)); node->value = value; for (int i = 0; i < 26; i++) { node->children[i] = NULL; } node->is_end = 0; return node; } void insert(TrieNode *root, char *word) { TrieNode *curr = root; int len = strlen(word); for (int i = 0; i < len; i++) { int index = word[i] - 'a'; if (curr->children[index] == NULL) { curr->children[index] = createNode(word[i]); } curr = curr->children[index]; } curr->is_end = 1; } int search(TrieNode *root, char *word) { TrieNode *curr = root; int len = strlen(word); for (int i = 0; i < len; i++) { int index = word[i] - 'a'; if (curr->children[index] == NULL) { return 0; } curr = curr->children[index]; } return curr->is_end; } int main() { TrieNode *root = createNode('\0'); char word[MAX_WORD_LEN]; int choice = 0; do { printf("1. Insert Word\n"); printf("2. Search Word\n"); printf("3. Exit\n"); printf("Enter Choice: "); scanf("%d", &choice); switch (choice) { case 1: printf("Enter Word to Insert: "); scanf("%s", word); insert(root, word); break; case 2: printf("Enter Word to Search: "); scanf("%s", word); if (search(root, word)) { printf("%s is present in the dictionary.\n", word); } else { printf("%s is not present in the dictionary.\n", word); } break; case 3: printf("Exiting...\n"); break; default: printf("Invalid Choice!\n"); break; } } while (choice != 3); return 0; } ``` 该实现中使用了一个 TrieNode 结构体来表示 Trie 树中的每个节点，其中包含了节点的值，子节点指针数组和一个标志位，用于指示该节点是否为单词的结尾。 在插入单词时，从根节点开始遍历 Trie 树，如果当前节点的相应子节点为空，则新建一个节点并将其作为当前节点的相应子节点。最后将单词的结尾节点的标志位设置为 1。 在查找单词时，同样从根节点开始遍历 Trie 树，如果当前节点的相应子节点为空，则说明该单词不存在于 Trie 树中。如果单词的最后一个字符所在的节点的标志位为 1，则说明该单词存在于 Trie 树中。 该实现中还包含了一个简单的命令行界面，用于接收用户的输入并执行相应的操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值