字典树经典例题

已于 2023-07-01 21:27:10 修改
阅读量155 收藏
点赞数
文章标签： 算法 c++ 开发语言
于 2023-06-24 07:59:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34603425/article/details/131344332
版权

之前讲了字典树的基本原理与代码实现，本文主要讲经典例题。

文章目录

LeetCode 208. 实现 Trie (前缀树)

在这里插入图片描述
解题思路：初始化、插入和查找都是基本的操作，StartWith操作没有见过。只需按查找的步骤来做StartWith, 不用判断最后一个字母是否独立成词，即可。

class Node {
public:
   Node() {
       flag = 0;
       for (int i = 0; i < 26; i++) {
           next[i] = nullptr;
       }
   }
   int flag;
   Node * next[26];
};
class Trie {
public:
   Trie() {
       root = new Node();
   }
   
   void insert(string word) {
       Node *p = root;
       for (auto x : word) {
           int ind = x - 'a';
           if (p->next[ind] == nullptr) p->next[ind] = new Node();
           p = p->next[ind];
       }
       p->flag = true;
   }
   
   bool search(string word) {
       Node *p = root;
       for (auto x : word) {
           int ind = x - 'a';
           if (p->next[ind] == nullptr) return false;
           p = p->next[ind];
       }
       return p->flag;
   }
   
   bool startsWith(string prefix) {
       Node *p = root;
       for (auto x : prefix) {
           int ind = x - 'a';
           if (p->next[ind] == nullptr) return false;
           p = p->next[ind];
       }
       return true;
   }
   Node *root;
};

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

提交结果：
在这里插入图片描述
总结：复习常规方法实现的字典树。

LeetCode 1268. 搜索推荐系统

在这里插入图片描述
题目分析：
在常规字典树的实现中，每一个节点额外存一个字符串集合。
在插入单词的过程中，把当前单词插入到每一个节点的集合中去。当当前节点中的单词大于3个时，就删掉排名最大的那个单词。如下图：
在这里插入图片描述
如此将products中的单词都插入到字典树中后，再对searchWord 进行查找。
然后查找搜索的过程中，每次搜到一个节点，就把当前节点对应集合中的字符串都加到结果二维数组中。

class Node {
public:
    Node() {
        flag = 0;
        for (int i = 0; i < 26; i++) {
            next[i] = nullptr;
        }
        s = set<string> ();
    }
    ~Node() {}
    int flag;
    Node * next[26];
    set<string> s;
};
class Trie {
public:
    Trie() {
        root = new Node();
    }
    void clearTrie(Node *root) {
        if (root == nullptr) return;
        for (int i = 0; i < 26; i++) {
            clearTrie(root->next[i]);
        }
        return;
    }
    ~Trie() {
        clearTrie(root);
    }
    
    void insert(string word) {
        Node *p = root;
        for (auto x : word) {
            int ind = x - 'a';
            if (p->next[ind] == nullptr) p->next[ind] = new Node();
            p = p->next[ind];
            p->s.insert(word);
            if (p->s.size() > 3) {
                auto iter = p->s.end();
                iter--;
                p->s.erase(iter);
            }
        }
        p->flag = true;
    }
    
    vector<vector<string>> search(string word) {
        Node *p = root;
        vector<vector<string>> ret;

        for (auto x : word) {
            int ind = x - 'a';
            if (p == nullptr) {
                //上一个遍历到的节点为空
                ret.push_back(vector<string>() );
                continue;
            };
            p = p->next[ind];
            vector<string> temp;
            if (p != nullptr) {
                //当前遍历到的节点不为空
                for (auto x : p->s) {
                    temp.push_back(x);
                }
            }
            ret.push_back(temp);
            
        }
        return ret;
        
    }
    Node *root;
};


class Solution {
public:
    vector<vector<string>> suggestedProducts(vector<string>& products, string searchWord) {
        Trie root;
        for (auto x : products) root.insert(x);
        return root.search(searchWord);
    }
};

代码提交结果：
在这里插入图片描述
总结：在常规字典树实现的基础上进行了一些改动，从而实现题目要求的结果。字典树的实现是采用了最基础的版本，未做优化。
也可以看出，字典树很难进行统一的一个封装，因为一般是需要根据实际业务场景，进行统一的一个封装和优化改动。

剑指 Offer II 067. 最大的异或

在这里插入图片描述
题目分析：

  1. 什么是异或 XOR？ 逐位比较两个二进制数，相同，则结果位为0，不相同则结果位为1。
    如下图，5和9的结果经过二进制逐位计算后，结果为12：
    在这里插入图片描述

  2. 本题如果用常规方法，暴力遍历，会超时。

  3. 异或运算的升华理解：
    异或运算本质上是二进制中1的个数的奇偶性，如果1的个数为奇数个，结果就是1；1的个数为偶数个，结果就是0.

  4. 那么怎么样才能让异或的结果最大呢？就是让从高位到低位，结果所包含的0和1尽可能的不一样。

  5. 如此就可以将问题转化为，当我们拿到一个数字a的时候，找到另一个数字b，使得b和a从高位到低位，尽可能得不一样。 转化成了这样一个等价问题。

    比如当前数字a为“1001”, 那么目标数字b的最高位尽可能为0， 然后第二位尽可能是1， 第三位和第四位尽可能是1,0，也就是说b尽可能是“0110”。

  6. 所以可以把每个数字转换为二进制，分别插入字典树中去（对于本题需要一个二叉字典树，每个节点下面有两条边，一条代表0， 一条代表1）。

    接下来就是拿着每个数字，在字典树中查找和当前数字“尽可能不一样的那个数字”。查找的过程中，就可以把结果算出来。
    举例：
    假设现在有三个数字，0110，1010，1100。构建二叉树以及查找“0110”对应的最大疑惑数字过程如下：
    在这里插入图片描述
    所以在这三个数字中，找到关于“0110”的最大异或数字就是“1010”。
    代码演示：

class Node {
public:
    Node() {
        flag = 0;
        for (int i = 0; i < 2; i++) {
            next[i] = nullptr;
        }
    }
    int flag;
    Node * next[2]; //二叉字典树
};
class Trie {
public:
    Trie() {
        root = new Node();
    }
    
    void insert(int num) {
        Node *p = root;
        
        for (int i = 31; i >= 0; i--) {
        	//从高位到低位插入
            int ind = (num & (1 << i)) > 0 ? 1 : 0;
            //(也可以写作 !!(num & (1 << i))),c++中的归一化技巧
            //num的第i位二进制
            if (p->next[ind] == nullptr) p->next[ind] = new Node();
            p = p->next[ind];
        }
        p->flag = true;
        //在这种插入方式下，字典树的深度一定是32， 
        //而且一定是最后一层的所有节点flag均为true, 其余节点的flag都不是true
    }
    
    int search(int num) {
    	//返回当前字典树中和num形成的最大异或值是多少
        Node *p = root;
        int ret = 0;
        int target = 0;
        for (int i = 31; i >= 0; i--) {
            int ind =  (num & (1 << i)) > 0 ? 1 : 0;  //与num的第i位二进制相同
            //(也可以写作 !!(num & (1 << i)))
            int ind_diff = 1 - ind; //与num的第i位二进制不同
            if (p->next[ind_diff] != nullptr) { //首先查找i位二进制不同的
                p = p->next[ind_diff];
                if (ind_diff == 1) target |= (1 << i);
            }else if (p->next[ind] != nullptr) { //再查找i位二进制相同的
                p = p->next[ind];
                if (ind == 1) target |= (1 << i);
            }
        }
        return target ^ num;  //查到了最后一层，最后一层的flag一定是true
    }

    Node *root;
};

class Solution {
public:
    int findMaximumXOR(vector<int>& nums) {
        Trie trie;
        for (auto x : nums) trie.insert(x);
        int ret = 0;
        for (auto x : nums) {
            int temp = trie.search(x);
            if (temp > ret) ret = temp;
        } 
        return ret;
    }
};

代码提交结果：
在这里插入图片描述
总结：异或的深化理解，用二叉字典树解决问题，查找时有目的的查找，而不是像普通字典树那样查找相同的。

241. 为运算表达式设计优先级

在这里插入图片描述
题目解析：
要给出一个表达式所有的可能结果，表达式的结果和运算符的运算顺序有关系。
给一个表达式加不同的括号，所影响的也就是表达式的运算顺序。
所以问题就是如何枚举表达式运算符的顺序。
把表达式看成一棵树，树的根节点就是表达式中最后一个需要计算的运算符。
例如“2 - 1 - 1”，有以下两种可能的运算顺序：
在这里插入图片描述

递归问题，枚举表达式根节点的问题，将当前表达式中所有运算符都当做根节点，去计算一遍，获得当前运算符 左边所有的可能结果，和右边所有的可能结果，左右两边所有的可能结果之间做个组合，然后就可以得到当前运算符作为根节点时，所有的可能结果。
例如最后一个运算符时“+”，此时左边所有可能结果是【2,3,9】，右边所有可能的结果是【5,7】，那么最终结果就有六种可能（2+5, 2+7, 3+5, 3+7, 9+5, 9+7）。
在这里插入图片描述

class Solution {
public:
    vector<int> diffWaysToCompute(string expression) {
        vector<int> ret;
        for (int i = 0; expression[i]; i++) {
            char op = expression[i];
            if (op != '+' && op != '-' && op != '*') {
                continue;
            }
            string a_str = expression.substr(0, i);
            string b_str = expression.substr(i + 1, expression.size());
            vector<int> a = diffWaysToCompute(a_str);
            vector<int> b = diffWaysToCompute(b_str);
            for (auto x : a){
                for (auto y : b) {
                    switch (op) {
                        case '+' : ret.push_back(x + y); break;
                        case '-' : ret.push_back(x - y); break;
                        case '*' : ret.push_back(x * y); break;
                    }
                }
            }
            
        }
        if (ret.size() == 0) {
                int num = 0;
                for (auto x : expression) {
                    num = num * 10 + (x - '0');
                }
                ret.push_back(num);
        }
        return ret;
    }
};

提交结果：
在这里插入图片描述
总结：整体思路较为清晰，就是需要把一个表达式看成一棵二叉树。

LeetCode 133. 克隆图

在这里插入图片描述
在这里插入图片描述
题目解析：可以在深度遍历的过程中克隆，遍历的过程中某些节点可能遍历过，此时可以用一个哈希表来记录克隆的节点。

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> neighbors;
    Node() {
        val = 0;
        neighbors = vector<Node*>();
    }
    Node(int _val) {
        val = _val;
        neighbors = vector<Node*>();
    }
    Node(int _val, vector<Node*> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
};
*/

class Solution {
public:
    unordered_map<Node *, Node *> h;
    Node* cloneGraph(Node* node) {
        if (node == nullptr) return nullptr;
        
        Node *node1 = new Node(node->val);
        
        if (h[node]) return h[node]; //之前克隆过
        h[node] = node1;
        for (int i = 0; i < node->neighbors.size(); i++) {
            node1->neighbors.push_back(cloneGraph(node->neighbors[i]));
        }
        // printf("node val : %d ", node1->val);
        // for (int i = 0; i < node1->neighbors.size(); i++) {
        //     printf("i : %d , nei[i]: %d ", i, node1->neighbors[i]->val);
        // }
        // printf("\n");
        return node1;
    }
};

代码提交结果：
在这里插入图片描述
总结：图的深度遍历，用哈希表记录是否遍历过。

LeetCode 987. 二叉树的垂序遍历

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
解题思路：
可以首先遍历这棵树，然后把这棵树种的每个节点，和节点相应的坐标，打包到一块儿，最后把打包的信息，按照题目要求，整理成题目需要的样子。
在这个处理过程中，涉及到了信息转换的问题，所以本题主要考察信息转换的能力。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    typedef pair<int, int> PII;
    map<int, vector<PII>> h; //j, [<i, val>] //哈希表用红黑树实现，遍历时key是有序的
    void getResult(TreeNode *root, int i, int j) { //深度遍历
        if (root == nullptr) return;
        int val = root->val;
        h[j].push_back(PII(i, val));
        getResult(root->left, i + 1, j - 1);
        getResult(root->right, i + 1, j + 1);
        return;
    }
    vector<vector<int>> verticalTraversal(TreeNode* root) {
        getResult(root, 0, 0); //信息转换存储到哈希表中
        vector<vector<int>> ret;
        for (auto item : h) {
            // cout << item.first << endl;
            // item.first代表k, item.second代表value
            vector<PII> &arr = item.second;
            sort(arr.begin(), arr.end()); //题目中要求的比较规则，正好就是c++中PII默认的比较规则
            vector<int> temp;
            for (auto x : arr) temp.push_back(x.second);
            ret.push_back(temp);
        }

        return ret;

    }
};

代码提交结果：
在这里插入图片描述
总结：将一个大问题转换为两个小问题，先把信息转换成哈希表的另一种形式，然后遍历哈希表，按照要求的格式来排序，给出结果。

LeetCode 611. 有效三角形的个数

在这里插入图片描述
题目分析：可以将数组排序后，依次遍历三角形的前两个边长，然后通过二分查找第三条边的边长，第三条边需满足：小于前两条边长之和即可。
所以二分查找相当于前面在给定范围的有序数组中查找第一个大于等于某个target的数，即前面一堆0，后面一堆1， 找第一个1；0代表小于某个target， 1代表大于等于这个target。

class Solution {
public:
    int triangleNumber(vector<int>& nums) {
        int n = nums.size();
        if (n < 3) return 0;
        int ret = 0;
        sort(nums.begin(), nums.end());
        for (int i = 0; i <= n - 3; i++) {
            for (int j = i + 1; j <= n - 2; j++) {
                // j + 1, n - 1, 000,111  找到第一个大于等于 ni + nj的下标
                int l = j + 1, r = n; //r的选择假设数组的最后一位存在一个虚拟的数，这个数一定大于target。
                int target = nums[i] + nums[j];
                while (l < r) {
                    int mid = (l + r) / 2;
                    if (nums[mid] < target) {
                        l = mid + 1;
                    }else {
                        r = mid;
                    }
                }
                //l或r就是找到的下标
                // printf("%d %d %d \n", i,j,l);
                ret += (r - j - 1);
            }
        }
        return ret;
    }
};

代码提交结果：
在这里插入图片描述
总结：排序与巧用二分法。

LeetCode 440. 字典序的第K小数字

在这里插入图片描述
解析：可以将数字构造成一个字典树，即十叉树，然后前序遍历这个字典树，当遍历到第k个数的时候就找到了要求的数，但是这样构建字典树，再遍历的方法会超时。
但是本题中的字典树一定是一个完全树，即除了最后一层外其他层一定是满的，最后一层的节点都是靠左边的。因为1-n的数字是连续的。
所以给定一个节点值后，其实可以通过计算得到以这个节点为根节点时，字典树一共有多少个节点。
知道每个节点的节点值如何计算以后，就可以从“1”节点入手，去看每个节点下面有多少个节点，根据节点的个数和k的大小关系，判断下一步应该向子节点中去找，还是去下一棵树中去找。
而计算某个节点下面有多少个子节点，可以通过逐层计算的方式，第一层一定是一个节点（num），第二层一定是10个（num * 10，num * 10 + 1， …，num + 10 + 9），第三层100个，以此类推。如果某一层的最后一个数都小于等于n，那这层一定是满的，反之如果某一层的最后一个数（比如 num * 10000 + 9999）大于了n，这层就没有满，可以通过n和这层的第一个数的差得到这层的节点数量。

class Solution {
public:
    int calNodeNum(int num, int n) {
        int ret = 0;
        int x = num, base = 1;
        int thresh = 1e9; //thresh防止计算某一层节点的最后一个数的时候超过整数范围，如果num是个位数，thresh就是1e9，如果num是十位数，thresh就是1e8，以此类推。
        while (x >= 10) {
            x /= 10;
            thresh /= 10;
        }
		//base代表这一层的节点个数
        while (num * base + base - 1 <= n) {
            ret += base;
            base *= 10;
            if (base == thresh) break; //因为while循环中num * base + base - 1 可能会超过整数的范围，所以提前判断一下，如果base的值到了一定阈值，那就直接不从一层去找了，因为一定不存在。
        }
        if ((base < thresh) && (num * base <= n)){
            ret += (n - num * base + 1);  //最后一层没满，base >= thresh的时候一定不存在最后一层
        }
        // printf("num %d, n %d, ret %d\n", num, n, ret);
        return ret;
        // 10 11 12 13 14
    }
    int findFromNumber(int num, int n, int k) {
        if (k == 1) return num; //前序遍历num节点的第一个数就是num
        int nodeNum = calNodeNum(num, n); //num节点为根节点时一共有多少个节点
        // printf("num %d, n %d, k %d, nodeNum %d \n", num, n, k, nodeNum);
        if (nodeNum < k) return findFromNumber(num + 1, n, k - nodeNum); //当前根节点的节点个数太少，从下一个节点去找
        if (nodeNum >= k) return findFromNumber(num * 10, n, k - 1);
		//当前树的节点的个数较多，从第一个子节点树中去找。
        return 0;
    } 
    int findKthNumber(int n, int k) {
        return findFromNumber(1, n, k);
    }
};

代码提交结果：
在这里插入图片描述
总结：也是字典树的思想，前序遍历。相当于构建了一棵字典树，而且构建的时候记录了每个节点下方的总节点个数。但是由于本题数据的特殊性质，不需要真正构建一棵树，每个节点下方的节点个数也可以通过计算来得到。

非英杰不图
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
字典树_字典树_
10-03
字典树代码dictionary，包含数据结构和测试例程。
字典树题目总结
天亮说晚安
02-17 3707
Trie 就好比维护了一个字典，可以在这个字典里插入删除字符串，也可以查询一个字符串是否在字典中。Trie的插入查找删除复杂度都是O(m)的，其中m为待插入串的长度。 Trie的原理是利用字符串集合中字符串的公共前缀来降低时间开销以达到提高效率的目的。 HDU1251-统计难题： 最简单的字典树题，对于字典中的字符串插入后依次回答询问子串个数即可。 解题报告
[ 字典树题目 ]
Acer12138的博客
09-06 330
Problem Description Ignatius最近遇到一个难题,老师交给他很多单词(只有小写字母组成,不会有重复的单词出现),现在老师要他统计出以某个字符串为前缀的单词数量(单词本身也是自己的前缀). Input 输入数据的第一部分是一张单词表,每行一个单词,单词的长度不超过10,它们代表的是老师交给Ignatius统计的单词,一个空行代表单词表的结束.第二部分是一连串的提问,...
字典树题集
ShineEternal的笔记小屋
07-24 181
uva12333 p2922 https://www.luogu.org/problemnew/show/UVA11732 UVA11362 p2580 sp4033 https://www.luogu.org/problemnew/show/P4551 https://www.luogu.org/problemnew/show/P2420
字典树习题
AI_xue
02-22 415
http://acm.hdu.edu.cn/showproblem.php?pid=1251 hdu1251 题意：先几个单词空一行再给几个前缀，判断每个前缀在单词中出现的次数 做法：设置count在字典树中，对于字符串，走到每个字符时都把count ++。查找到时候，如果未走到头就是1，走到头了就是count
字典树的题目 找了个时间刷了一点字典树的题目
sdut_jean的博客
04-26 1221
http://acm.sdut.edu.cn/onlinejudge2/index.php/Home/Contest/contestproblem/cid/2009/pid/2828 #include #include #include #include #include using namespace std; struct node { int v; node
字典树_英汉词典
05-19
字典树，文档，增删改，排序，输出字典所有单词及意思
acm 算法 字典树模板
05-29
acm字典树模板！acm字典树模板！acm字典树模板！acm字典树模板！
通过读入文本构建字典树
02-10
主要功能 有读取文本中的单词 通过单词前缀 获取单词信息 打印字典树
Trie树_字典树(字符串排序)简介及实现
10-26
有时，我们会碰到对字符串的排序，若采用一些经典的排序算法，则时间复杂度一般为O(n*lgn)，但若采用Trie树，则时间复杂度仅为O(n)
字典树相关的算法题目
客舟中
03-26 793
1. 字典树的实现 208. 实现 Trie (前缀树) 请你实现 Trie 类： Trie() ：初始化前缀树对象。 void insert(String word)： 向前缀树中插入字符串 word 。 boolean search(String word)： 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。 boolean startsWith(String prefix) ：如果之前已经插入的字符串word 的前缀之一为 prefix ，.
LeetCode 题集：字典树
星海浮生
11-10 5079
LeetCode 208. Implement Trie (Prefix Tree)（实现 Trie (前缀树)） 211. Design Add and Search Words Data Structure（添加与搜索单词 - 数据结构设计） 212. Word Search II（单词搜索 II）
Xor Sum （01字典树）基础的字典树题目
nhl19961226的博客
11-05 267
初学字典树的可以拿这道题练练手。题目链接：传送门题目大意：给你n个数，有m次询问，每次给个数，问：这个数与n个数中的哪个数的异或值最大，输出它。给大家两种写法； 1。数组的写法：#include <cstdio> #include <cstring> #include <iostream>using namespace std; //typedef __int64 ll; typedef long
字典树专题
wangheng
07-31 3246
字典树   又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。 它有3个基本性质： 根节点不包含字符，除根节点外每一个节点都只包含一个字符。从根节点到某一
字典树（trie）题库+详解
mapleaf的博客
07-24 926
字典树 #include <bits/stdc++.h> using namespace std; const int maxn=1e6+10; int sum[maxn]={0}; int trie[maxn][26]; char s[15]; int pos=1; void add() //插入 { int c=0; for(int i=0;s[i];i++) ...
01字典树专题
Miracle_ma的专栏
05-23 4059
以前一直以为字典树没有多少用，但是最近一直碰到（难道是以前刷题太少的原因么），其中有一类问题叫做01字典树问题，它是用来解决xor的有力武器，通常是给你一个数组，问你一段连续的异或和最大是多少，正常思路贪心dp啥的都会一头雾水，但是用01字典树就能很快的解决，实现起来也十分方便。 贴一个01字典树的普遍模版int ch[32*MAX][2]; LL val[32*MAX]; int sz;void
HDU1075 不错的字典树题
Start_to_crazy的博客
01-24 244
题意： 给你多条英语对应火星文，然后在下面输入一堆火星文，要你翻译成英文，如果一些火星文没有对应的英文的话就输出原火星文就可以了，有就输出英文。 题解： 一看到这道题就想到了map容器，奈何挺久没用过了，导致我很难下手，还是去看了别人怎么写的记忆才慢慢复苏，怎么说呢，STL是个神器，但是我用不习惯。。。ORZ，既然这道题是一道字典树的题目的话，咱们就用字典树的做法去做吧。
Leetcode刷题：字典树 类型题目总结
九九六.爱吸油
03-17 805
词典中最长的单词 给出一个字符串数组 words 组成的一本英语词典。返回 words 中最长的一个单词，该单词是由 words 词典中其他单词逐步添加一个字母组成。 若其中有多个可行的答案，则返回答案中字典序最小的单词。若无答案，则返回空字符串。 原文链接： https://leetcode-cn.com/problems/longest-word-in-dictionary/ 解题思路 涉及到前缀，便考虑使用字典树结构用于存储相同前缀的内容，当然本题也可以用hash表进行存储 遍历每个字符串，若前缀
字典树入门详解+一道入门水题
永不止步的博客
08-08 1000
字典树又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高（引用百度百科） 如下图：字典树的结构定义：typedef struct node{ node *next[26];
默克尔帕特里夏字典树
最新发布
03-12
默克尔帕特里夏字典树（Merkle Patricia Trie）是一种用于存储和检索键值对的数据结构，它是以默克尔哈希树（Merkle Hash Tree）和帕特里夏树（Patricia Tree）为基础而设计的。 默克尔帕特里夏字典树主要用于以太...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值