剑指offer62-67排序-前缀树

最新推荐文章于 2024-02-28 14:53:49 发布
最新推荐文章于 2024-02-28 14:53:49 发布
阅读量237 收藏
点赞数
分类专栏： LeetCode 文章标签： 数据结构 java c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_41553551/article/details/126656090
版权

剑指 Offer II 062. 实现前缀树

Trie（发音类似 “try”）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。

请你实现 Trie 类：

Trie() 初始化前缀树对象。
void insert(String word) 向前缀树中插入字符串 word 。
boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。
boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ，返回 true ；否则，返回 false 。

实现这种结构
在这里插入图片描述

方法

定义一个类，这个类是由一个vector和isEnd组成，前者是存放26个孩子节点，后者表示单词是否已经结束
在这里插入图片描述
搜索前缀。比如Anthony，an就是它的一个前缀，下面方法可以检验an是否是这个单词的前缀
在这里插入图片描述
搜索这个单词
在这里插入图片描述

class Trie {
private:
    vector<Trie*> children;
    bool isEnd;

    Trie* searchPrefix(string prefix) {
        Trie* node = this;
        for (char ch : prefix) {
            ch -= 'a';
            if (node->children[ch] == nullptr) {
                return nullptr;
            }
            node = node->children[ch];
        }
        return node;
    }

public:
    Trie() : children(26), isEnd(false) {}

    void insert(string word) {
        Trie* node = this;
        for (char ch : word) {
            ch -= 'a';
            if (node->children[ch] == nullptr) {
                node->children[ch] = new Trie();
            }
            node = node->children[ch];
        }
        node->isEnd = true;
    }

    bool search(string word) {
        Trie* node = this->searchPrefix(word);
        return node != nullptr && node->isEnd;
    }

    bool startsWith(string prefix) {
        return this->searchPrefix(prefix) != nullptr;
    }
};

剑指 Offer II 063. 替换单词

在英语中，有一个叫做 词根(root) 的概念，它可以跟着其他一些词组成另一个较长的单词——我们称这个词为 继承词(successor)。例如，词根an，跟随着单词 other(其他)，可以形成新的单词 another(另一个)。

现在，给定一个由许多词根组成的词典和一个句子，需要将句子中的所有继承词用词根替换掉。如果继承词有许多可以形成它的词根，则用最短的词根替换它。

需要输出替换之后的句子。

输入：dictionary = [“cat”,“bat”,“rat”], sentence = “the cattle was rattled by the battery”
输出：“the cat was rat by the bat”

题目意思，cattle有cat，将cattle替换成cat

方法：将给的数组插入前缀树，将句子分解为单词，逐个单词遍历前缀树

// 构造前缀树节点
class Trie {
private:
    bool isWord;
    vector<Trie*> children;
public:
    Trie () : isWord(false), children(26, nullptr) {}

    void insert(const string& str) {
        Trie* node = this;
        for (auto& ch : str) {
            if (node->children[ch - 'a'] == nullptr) {
                node->children[ch - 'a'] = new Trie();
            }
            node = node->children[ch - 'a'];
        }
        node->isWord = true;
    }

    int countPreFixLen(const string& str) {
        Trie* node = this;
        int len = 0;
        for (auto& ch : str) {
            if (node->children[ch - 'a'] == nullptr) {
                return 0;
            }
            node = node->children[ch - 'a'];
            len++;
            if (node->isWord) {
                return len;
            }
        }
        return 0;
    }
};

class Solution {
public:
    string replaceWords(vector<string>& dictionary, string sentence) {
        Trie* root = new Trie();
        for (string& word : dictionary) {
            root->insert(word);
        }
        
        // 分割
        vector<string> words{""};
        for (auto& ch : sentence) {
            if (ch != ' ') {
                words.back().push_back(ch);
            }
            else {
                words.push_back("");
            }
        }

        // 处理
        vector<string> ret;
        for (auto& word : words) {
            int len = root->countPreFixLen(word);
            if (len == 0) {
                ret.emplace_back(word);
            }
            else {
                ret.push_back(word.substr(0, len));
            }
        }

        // 拼接
        string ans{""};
        for (auto& word : ret) {
            ans += word;
            ans += " ";
        }
        ans.pop_back();

        return ans;
    }
};

剑指 Offer II 064. 神奇的字典

设计一个使用单词列表进行初始化的数据结构，单词列表中的单词 互不相同 。 如果给出一个单词，请判定能否只将这个单词中一个字母换成另一个字母，使得所形成的新单词存在于已构建的神奇字典中。

实现 MagicDictionary 类：

MagicDictionary() 初始化对象
void buildDict(String[] dictionary) 使用字符串数组 dictionary 设定该数据结构，dictionary 中的字符串互不相同
bool search(String searchWord) 给定一个字符串 searchWord ，判定能否只将字符串中 一个 字母换成另一个字母，使得所形成的新字符串能够与字典中的任一字符串匹配。如果可以，返回 true ；否则，返回 false 。

输入
inputs = [“MagicDictionary”, “buildDict”, “search”, “search”, “search”, “search”]
inputs = [[], [[“hello”, “leetcode”]], [“hello”], [“hhllo”], [“hell”], [“leetcoded”]]
输出
[null, null, false, true, false, false]

解释
MagicDictionary magicDictionary = new MagicDictionary();
magicDictionary.buildDict([“hello”, “leetcode”]);
magicDictionary.search(“hello”); // 返回 False
magicDictionary.search(“hhllo”); // 将第二个 ‘h’ 替换为 ‘e’ 可以匹配 “hello” ，所以返回 True
magicDictionary.search(“hell”); // 返回 False
magicDictionary.search(“leetcoded”); // 返回 False

将一个单词替换一个字母能够匹配已经存在的单词，比如已经有了hello，将hhllo中的h替换为e便成了hello

方法 前缀树遍历遇到异常时递归

构造前缀树，定义一个全局变量edit用来表示已经容错的个数，最大是1

在这里插入图片描述

class Trie {
public:
    vector<Trie*> children;     //当前节点的子孩子
    bool isEndPoint;
public:
    Trie() {
        children.resize(26);
        isEndPoint = 0;
    }

    void insert(string& word)
    {
        Trie* node = this;
        for (char& ch : word)
        {
            int idx = ch - 'a';
            if (node->children[idx] == nullptr)
                node->children[idx] = new Trie();
            node = node->children[idx];
        }
        node->isEndPoint = 1;
    }
};

class MagicDictionary {
private:
    Trie* trie;
public:
    //pos为word的当前字符位置
    bool dfs(Trie* node, string& word, int pos, int& edit)
    {
        //如果找到叶子节点都没成功
        if (node == nullptr)
            return false;

        //如果刚好到达字符串末尾，且node处于根节点，且只被修改过一个字符
        if (node->isEndPoint && pos == word.length() && edit == 1)
            return true;

        if (pos != word.length() && edit <= 1)
        {
            //遍历当前节点的所有子节点，
            for (int i = 0; i < 26; ++i)
            {
                //如果子节点存在，edit不变；否则，edit加1；
                int next = (i == (word[pos] - 'a')) ? edit : edit + 1;
                if (dfs(node->children[i], word, pos + 1, next))
                    return true;
            }
        }
        return false;
    }

    /** Initialize your data structure here. */
    MagicDictionary() {
        trie = new Trie();
    }

    void buildDict(vector<string> dictionary) {
        for (string& str : dictionary)
            trie->insert(str);
    }

    bool search(string searchWord) {
        int pos = 0, edit = 0;
        return dfs(trie, searchWord, pos, edit);
    }
};

剑指 Offer II 065. 最短的单词编码

单词数组 words 的 有效编码 由任意助记字符串 s 和下标数组 indices 组成，且满足：

words.length == indices.length
助记字符串 s 以 ‘#’ 字符结尾
对于每个下标 indices[i] ，s 的一个从 indices[i] 开始、到下一个 ‘#’ 字符结束（但不包括 ‘#’）的 子字符串 恰好与 words[i] 相等
给定一个单词数组 words ，返回成功对 words 进行编码的最小助记字符串 s 的长度 。

输入：words = [“time”, “me”, “bell”]
输出：10
解释：一组有效编码为 s = “time#bell#” 和 indices = [0, 2, 5] 。
words[0] = “time” ，s 开始于 indices[0] = 0 到下一个 ‘#’ 结束的子字符串，如加粗部分所示 “time#bell#”
words[1] = “me” ，s 开始于 indices[1] = 2 到下一个 ‘#’ 结束的子字符串，如加粗部分所示 “time#bell#”
words[2] = “bell” ，s 开始于 indices[2] = 5 到下一个 ‘#’ 结束的子字符串，如加粗部分所示 “time#bell#”

“time”, “me”, “bell” time的me和me重复，所以time ，me变为了time，time和bell没有重复，所以变为了time ，bell

方法：前缀树倒叙插入

在这里插入图片描述
最后统计节点的个数

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

剑指 Offer II 066. 单词之和

实现一个 MapSum 类，支持两个方法，insert 和 sum：

MapSum() 初始化 MapSum 对象
void insert(String key, int val) 插入 key-val 键值对，字符串表示键 key ，整数表示值 val 。如果键 key 已经存在，那么原来的键值对将被替代成新的键值对。
int sum(string prefix) 返回所有以该前缀 prefix 开头的键 key 的值的总和。
输入：
inputs = [“MapSum”, “insert”, “sum”, “insert”, “sum”]
inputs = [[], [“apple”, 3], [“ap”], [“app”, 2], [“ap”]]
输出：
[null, null, 3, null, 5]

解释：
MapSum mapSum = new MapSum();
mapSum.insert(“apple”, 3);
mapSum.sum(“ap”); // return 3 (apple = 3)
mapSum.insert(“app”, 2);
mapSum.sum(“ap”); // return 5 (apple + app = 3 + 2 = 5)

前缀树，插入时如果分支存在则用新的值替代原来的值，sum时是计算共同前缀的和，比如求a，则将所以单词是a的单词对应的值全部计算

方法前缀树

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

代码

// 构造前缀树节点
class Trie {
public:
    vector<Trie*> children;
    Trie() : children(26, nullptr) {}
};

// 构造前缀树节点
class Trie {
public:
    int val;
    vector<Trie*> children;
    Trie() : val(0), children(26, nullptr) {}

    // 实现插入字符串
    void insert(string& str, int m) {
        Trie* node = this;
        for (auto& ch : str) {
            if (node->children[ch - 'a'] == nullptr) {
                node->children[ch - 'a'] = new Trie();
            }
            node = node->children[ch - 'a'];
        }
        node->val = m;
    }

    // 实现返回所有以该前缀 prefix 开头的键 key 的值的总和
    int coutSum(string& prefix) {
        Trie* node = this;
        for (auto& ch : prefix) {
            if (node->children[ch - 'a'] == nullptr) {
                return 0;
            }
            node = node->children[ch - 'a'];
        }

        // BFS
        int count = 0;
        queue<Trie*> que;
        que.push(node);
        while (!que.empty()) {
            Trie* node = que.front();
            que.pop();
            count += node->val;
            for (int i = 0; i < node->children.size(); ++i) {
                if (node->children[i] != nullptr) {
                    que.push(node->children[i]);
                }
            }
        }
        return count;
    }
};

剑指 Offer II 067. 最大的异或

给定一个整数数组 nums ，返回 nums[i] XOR nums[j] 的最大运算结果，其中 0 ≤ i ≤ j < n 。
输入：nums = [3,10,5,25,2,8]
输出：28
解释：最大运算结果是 5 XOR 25 = 28.

方法：前缀找相反位

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

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

在这里插入图片描述

贪睡的蜗牛
关注
专栏目录
算法基础05-前缀树、桶排序、排序总结
weixin_42503072的博客
03-30 285
文章目录1 前缀树结构(trie)、桶排序、排序总结1.1 前缀树结构1.2 不基于比较的排序-桶排序1.2.1 计数排序1.2.2 基数排序1.3 排序算法的稳定性1.3.1 稳定的排序1.3.2 不稳定的排序1.3.3 排序稳定性对比1.4 排序算法总结1.5 排序常见的坑点1.6 工程上对排序的改进 1 前缀树结构(trie)、桶排序、排序总结 1.1 前缀树结构 单个字符串中，字符从前到后的加到一颗多叉树上 字符放在路上，节点上有专属的数据项(常见的是pass和end值) 所有样本都这样添
剑指Java面试-Offer直通车--redis
weixin_43271235的博客
06-28 499
前言：以下相关内容多为图片，参考链接、附上少量文字解释，以便整理脉络，以作复习巩固之用。若需详细了解，请查阅相关资料或者观看相关课程。如有错误，敬请指出，谢谢。 redis一、redis简介二、redis常用数据类型三、从海量数据里查询某一固定前缀的key四、如何实现分布式锁五、如何实现异步队列六、持久化方式之RDB七、持久化方式之AOF以及混合模式八、Pipeline及主从同步九、Redis集群 参考链接：搞懂这些Redis知识点 一、redis简介 Redis 是 C 语言开发的一个开源的（遵从 BSD
Trie树|字典树(字符串排序)
05-05 209
Trie树|字典树(字符串排序) Trie树|字典树(字符串排序) - Microgoogle - 博客园Trie树|字典树(字符串排序)有时，我们会碰到对字符串的排序，若采用一些经典的排序算法，则时间复杂度一般为O(n*lgn)，但若采用Trie树，则时间复杂度仅...
【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
堆，前缀树，桶排序_4
qq_44173324的博客
04-16 343
文章目录堆一个大根堆求最大值，并将这个最大值删掉，删掉后怎么形成新的完全二叉树堆排序前缀树（普通的树，而非二叉树）前缀树的代码实现：完成在一堆字符串的增加，删除，查找以及某前缀在这些字符串出现过几次桶排序计数排序代码基数排序代码排序算法的稳定性 堆 构建一个堆 * 堆是什么呢？ * 其实就是一个完全二叉树，即所有的父节点层不存在空的节点， * 最后一层节点的顺序必须按着顺序来，不能说左边没有节点，右边却有节点，那这样就不是完全二叉树了 * 堆又分为大根堆和小根堆 * 大根堆即父节点比它下面的子节点都要大，小
《剑指 Offer》专项突破版 - 面试题 62 : 详解前缀树以及实现（C++）
最新发布
melonyzzZ的博客
02-28 916
一、前缀树的基础知识 二、实现前缀树
剑指Offer（专项突破版）数据结构与算法名企面试题精讲1
08-03
《剑指Offer（专项突破版）数据结构与算法名企面试题精讲1》是一本专为程序员面试准备的数据结构与算法指南。作者何海涛结合自身多年的面试官经验，深入探讨了程序员在面试中必须掌握的核心知识。本书旨在帮助读者...
剑指offer程序
01-04
《剑指Offer》是一本备受推崇的编程面试指南，它为准备进入IT行业的求职者提供了大量实战性的编程题目。这个压缩包文件包含了该书中的部分练习程序，旨在帮助求职者熟悉并掌握常见的算法和数据结构问题，从而在面试...
《剑指Java面试-Offer直通车》--Redis
lucky_jiexia的博客
06-21 2564
一、Redis简介 MySQL的数据都是存放在磁盘中的，虽然在数据库层也做了对应的缓存，但这种数据库层次的缓存一般针对查询的内容，而且粒度也比较小。一般只有表中数据没有发生变动时，数据库对应的Cache才会发挥作用，这不能减少业务系统对数据库产生的增删改查的IO压力。因此缓存数据库应运而生，该技术实现了对热点数据的高速缓存，提高应用的响应速度，极大缓解后端数据库的压力。 缓存中间件--Memcache和Redis的区别 Memcache简单易用，代码层次类似Hash。支持简单数据类型；不支持数据持
考研数据结构和leetcode-Coding:coding能力需要每天加强练习~剑指offer~leetcode~
06-30
剑指offer~ leetcode~ 数据结构与算法 数据结构研究的是数据如何在计算机中组织和存储，使得我们可以高效地获取数据和修改数据。 我们需要根据应用场景的不同，灵活选择最合适的数据结构。 线性结构 数组 链表 栈 ...
Trie树_字典树(字符串排序)简介及实现
10-26
有时，我们会碰到对字符串的排序，若采用一些经典的排序算法，则时间复杂度一般为O(n*lgn)，但若采用Trie树，则时间复杂度仅为O(n)
前缀树（字典树）Trie Tree
qq_44709990的博客
05-13 423
前缀树（字典树）Trie Tree 前缀树 含义 Trie树，即前缀树，又称单词查找树或字典树，是一种树形结构。该树典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。 应用 题目：给你100000个长度不超过10的单词。对于每一个单词，我们要判断他出没出现过，如果出现了，求第一次出现在第几个位置。 在Trie树适用的状态下，很多情况同样可以使用hash树。但是Trie树用途更加的广泛，比如给一个字符串，要寻找有多少单词是以该字符串为前缀的问题。 代码解析 Tr
python_6_前缀树+非比较排序+排序算法部分总结
Jieyi_的博客
08-23 102
0:node.pas = node.pas - 1 # 经过路径p--if node.nexts[index].pas == 0: # 如果下方这个节点，p--值为0node.nexts[index] = None # 从父节点指向空return选择排序（不稳定）->选一个最小值放在前面冒泡排序（稳定）插入排序（）->从第一个数后，将后面的数按大小插入前面，变成有序。
字典树、树的遍历、二叉查找树
solumin的博客
07-27 712
字典树 前缀树 """ 一、题目 实现一个字典树or前缀树，包含insert、search和startswith功能 """ class Node(): def __init__(self): self.childs = [None] * 26 self.isLeaf = False class Trie(object): def _...
字典树 前缀树 Trie
qq_32400119的博客
04-03 232
介绍 Introduction 本章的重点是要回答以下两个问题： 什么是字典树 如果用代码来表示字典树 如果你对字典树不熟悉，那么本章将对你很有帮助。 1. 什么是字典树 What is Trie 字典树，又称前缀树，是一种特殊的多叉树，一般用来存储字符串。字典树的每个节点都代表一个字符串（或者前缀）。每个节点都有若干个子节点，并且从该节点通往每个子节点的路径代表着不同的字符。一个节点上的字符...
1.常见的排序算法及前缀树
weixin_46412362的博客
04-12 246
引言 在最近刷Leetcode的过程中，感觉自己为了刷题而刷题，思考太少了。虽然刷了400多了但是感觉遇到新的题还是会做的很吃力，因此打算从头扎扎实实的再过一遍数据结构与算法，所有的东西自己思考码一遍，这个专题过完之后补一些看书笔记。 本专题的顺序以左神的讲课顺序来排列，算是自己的一些课后总结吧，如有错误欢迎指正。 1.选择排序： 时间复杂度：O(N^2) 时间复杂度：O(1） 稳定性：不稳定 代码： void insectSort(std::vector<int>& vec) { f
前缀树讲解
weixin_53012351的博客
01-09 1233
前缀树 功能：以树的形式存放单词组 例： in inter input apple append 红色表示一个单词的结束 代码 先给出代码，运行了解一下前缀树的用处： #include <stdio.h> #include <string.h> #include <stdlib.h> typedef struct Tree { int count; struct Tree *child[26]; }Node,*Trie_node; Node *Cr
前缀树（字典树）总结-java版
许诗宇的博客
04-17 2893
目录 前缀树的概述 前缀树的应用场景 前缀树的java实现 节点 前缀树（增加，查询字符串数量，查询前缀数量） 测试 与DFA查询敏感词的类似与不同 类似 不同 前缀树的概述 前缀树又名字典树，单词查找树，Trie树，是一种多路树形结构，是哈希树的变种，和hash效率有一拼，是一种用于快速检索的多叉树结构。 典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经...
前缀树 - 一种好玩的树型数据结构
weixin_33806509的博客
10-13 220
上篇内容有在介绍 Gin 的路由实现时提到了前缀树，这次我们稍微深入探究一下前缀树的实现。本文以一道编程题为例，讲述前缀树的实现，以及前缀树的一种优化形态压缩前缀树。 MapSum 问题 LeetCode 上有一道编程题是这样的 实现一个 MapSum 类里的两个方法，insert和sum。对于方法insert，你将得到一对（字符串...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

贪睡的蜗牛

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

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

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

打赏作者

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

抵扣说明：

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

余额充值