leetcode--高级数据结构

最新推荐文章于 2022-03-16 09:22:25 发布
原创 最新推荐文章于 2022-03-16 09:22:25 发布 · 342 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了字典树（Trie树）的基本概念、数据结构及其实现方法，包括插入、查找、前缀查询等功能，并展示了如何利用正则表达式进行单词搜索。此外，还介绍了并查集的概念及其在解决朋友圈圈子问题中的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

基础知识：

Trie树（字典树）

利用字符串的公共前缀来减少储存空间和查询时间。

数据结构：

#define TRIE_MAX_CHAR_NUM 26
struct TrieNode{
    TrieNode *child[TRIE_MAX_CHAR_NUM];
    bool is_end;
    TrieNode() : is_end(false){
        for (int i = 0; i < TRIE_MAX_CHAR_NUM; i++){
            child[i] = 0;
        }
    }
};

获取全部单词：

前序遍历，放进一个栈，前序遍历压入节点，在后序遍历时弹出节点。

void get_all_word_from_trie(TrieNode *node, string &word, vector<string> &word_list){
    for (int i = 0; i < TRIE_MAX_CHAR_NUM; i++){
        if (node->child[i]){
            word.push_back(i + 'a');
            if (node->child[i]->is_end){
                word_list.push_back(word);
            }
            get_all_word_from_trie(node, word, word_list);
            word.erase(word.length()-1, 1);
        }
    }
}

插入

一个循环word遍历树的过程

void insert(const char *word, TrieNode root){
    TrieNode *ptr = &root;
    while(word){
        int pos = *word - 'a';
        if (!ptr->child[pos]){
            ptr->child[pos] = new TrieNode();
        }
        ptr = ptr->child[pos];
        word++;
    }
    ptr->is_end = true;
}

搜索

与插入类似，没找到节点返回false，到word最后字符，返回is_end的值。

bool search(const char *word, TrieNode root){
    TrieNode *ptr = &root;
    while(word){
        int pos = *word - 'a';
        if(!ptr->child[pos]){
            return false;
        }
        ptr = ptr->child[pos];
        word++;
    }
    return ptr->is_end;
}

前缀查询

搜索是否存在前缀，与字符串搜索类似，最后不是返回is_end而是存在就返回true。

bool startsWith(const char *word, TrieNode *root){
    TrieNode *ptr = root;
    while(word){
        int pos = *word - 'a';
        if(!ptr->child[pos]){
            return false;
        }
        ptr = ptr->child[pos];
        word++;
    }
    return true;
}

208. Implement Trie (Prefix Tree)

题意：

实现一个字典树，实现插入、查找、查找前缀的功能。

代码：

#define TRIE_MAX_CHAR_NUM 26

struct TrieNode{
    TrieNode* child[TRIE_MAX_CHAR_NUM];
    bool is_end;
    TrieNode() : is_end(false){
        for (int i = 0; i <= TRIE_MAX_CHAR_NUM; i++){
            child[i] = 0;
        }
    }
};


class Trie {
public:
    /** Initialize your data structure here. */
    Trie() {
    }

    /** Inserts a word into the trie. */
    void insert(string word) {
        TrieNode *ptr = &root;
        for(int i = 0; i < word.length(); i++){
            int pos = word[i] - 'a';
            if (!ptr->child[pos]){
                ptr->child[pos] = new TrieNode();
            }
            ptr = ptr->child[pos];
        }
        ptr->is_end = true;
    }

    /** Returns if the word is in the trie. */
    bool search(string word) {
        TrieNode* ptr = &root;
        for(int i = 0; i < word.length(); i++){
            int pos = word[i] - 'a';
            if (!ptr->child[pos]){
                return false;
            }
            ptr = ptr->child[pos];
        }
        return ptr->is_end;
    }

    /** Returns if there is any word in the trie that starts with the given prefix. */
    bool startsWith(string prefix) {
        TrieNode* ptr = &root;
        for(int i = 0; i < prefix.length(); i++){
            int pos = prefix[i] - 'a';
            if (!ptr->child[pos]){
                return false;
            }
            ptr = ptr->child[pos];
        }
        return true;
    }
private:
    TrieNode root;
};

211. Add and Search Word - Data structure design

题意：

实现一个数据结构，可以以正则表达式的形式搜索单词。就是.可以代表任意的字母。实现数据结构的添加和查找功能。

解题思路：

实现一个tire数，如果遇到字母正常遍历word，遇到.深度优先搜索遍历所有的节点。

代码：

#define TRIE_MAX_CHAR_NUM 26

struct TrieNode{
    TrieNode* child[TRIE_MAX_CHAR_NUM];
    bool is_end = false;
    TrieNode() : is_end(false){
        for (int i = 0; i < TRIE_MAX_CHAR_NUM; i++){
            child[i] = 0;
        }
    }
};

class WordDictionary {
public:
    /** Initialize your data structure here. */
    WordDictionary() {
    }
    ~WordDictionary() {
        for (int i = 0; i < node_vec.size(); i++){
            delete node_vec[i];
        }
    }

    /** Adds a word into the data structure. */
    void addWord(string word) {
        TrieNode *ptr = &root;
        for (int i = 0; i < word.length(); i++){
            int pos = word[i] - 'a';
            if (!ptr->child[pos]){
                ptr->child[pos] = new_node();
            } 
            ptr = ptr->child[pos];
        }
        ptr->is_end = true;
    }

    /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
    bool search(string word) {
        TrieNode *ptr = &root;
        return search_trie(word, ptr, 0);
    }

    bool search_trie(string word,TrieNode* node, int i){
        if (word[i] == '\0'){
            if (node->is_end){
                return true;
            }
            return false;
        }
        if (word[i] == '.'){
            for (int j = 0; j < TRIE_MAX_CHAR_NUM; j++){
                if (node->child[j] && search_trie(word, node->child[j], i+1)){
                    return true;
                }
            }
        }
        else{
            int pos = word[i] - 'a';
            if (node->child[pos] && search_trie(word, node->child[pos], i+1)){
                return true;
            }
        }
        return false;
    }
private:
    TrieNode* new_node(){
        TrieNode* node = new TrieNode();
        node_vec.push_back(node);
        return node;
    }
    TrieNode root;
    vector<TrieNode *> node_vec;
};

并查集：

概念：

通过森林的形式存集合，每个点记录父节点和子节点的个数，父节点等于自己则是根节点，在相同的集合的节点有相同的根节点。

初始化：

class DisjointSet{
public:
    DisjointSet(int n){
        for (int i = 0; i < n; i++){
            _id.push_back(i);
            _size.push_back(1);
        }
        count = n;
    }
private:
    vector<int> _id;
    vector<int> _size;
    int count;
};

路径压缩：

在查询时，隔一个把它连到它的父节点的父节点。
在并操作时，将子节点树少的节点连到子节点数多的根节点，使数尽可能的平衡。

查找操作：

int find(int p){
        while(p != _id[p]){
            _id[p] = _id[_id[p]]; //父节点指向了父节点的父节点
            p = _id[p];
        }
        return p;
    }

并操作：

void union_(int p, int q){
        int i = find(p);
        int j = find(q);
        if (i == j){
            return;
        }
        if (_size[i] > _size[j]){
            _id[j] = i;
            _size[i] += _size[j];
        }
        else{
            _id[i] = j;
            _size[j] += _size[i];
        }
        count--;
    }

547. Friend Circles

解题思路1：

利用并查集，返回集合个数。

代码：

class DisjointSet{
public:
    DisjointSet(int n){
        for (int i = 0; i < n; i++){
            _size.push_back(1);
            _id.push_back(i);
        }
        _count = n;
    }
    int find(int p){
        while (p != _id[p]){
            _id[p] = _id[_id[p]];
            p = _id[p];
        }
        return p;
    }
    void union_(int p, int q){
        int i = find(p);
        int j = find(q);
        if (i == j){
            return;
        }
        if (_size[i] > _size[j]){
            _id[j] = i;
            _size[i] += _size[j]; 
        }
        else{
            _id[i] = j;
            _size[j] += _size[i];
        }
        _count--;
    }
    int count(){
        return _count;
    }
private:
    vector<int> _id;
    vector<int> _size;
    int _count;
};

class Solution {
public:
    int findCircleNum(vector<vector<int>>& M) {
        DisjointSet disjoint_set(M.size());
        for (int i = 0; i < M.size(); i++){
            for (int j = i+1; j < M.size(); j++){
                if (M[i][j]){
                    disjoint_set.union_(i, j);
                }
            }
        }
        return disjoint_set.count();
    }
};

解题思路2：

深度优先搜素的方法：
遍历节点（如果visit数组为0），深度优先搜索该节点，设置一个visit数组，遍历过的节点的visit标记为1，计数需要经过多少次遍历可以遍历完所有的节点。

代码：

class Solution {
public:
    int findCircleNum(vector<vector<int>>& M) {
        vector<int> visit(M.size(), 0);
        int result = 0;
        for (int i = 0; i < visit.size(); i++){
            if (visit[i] == 0){
                DFS(M, visit, i);
                result++;
            }
        }
        return result;
    }

    void DFS(vector<vector<int>>& M, vector<int> &visit, int node){
        visit[node] = 1;
        for (int i = 0; i < M.size(); i++){
            if (M[node][i] == 1 && visit[i] == 0){
                DFS (M, visit, i);
            }
        }
    }
};

线段树

线段树是一个完全二叉树

leetcode答案-leetcode--python:leetcode--python
06-30
LeetCode提供了一系列的算法和数据结构问题，涵盖了许多知名公司的面试题目。它旨在帮助程序员锻炼解决问题的能力，学习新算法，并提高编码效率。平台支持多种编程语言，包括Python，Java，C++等，用户可以选择自己...
leetcode答案-leetcode-practice:leetcode-练习
06-30
LeetCode是一个广受欢迎的在线编程挑战平台，它提供了丰富的算法和数据结构问题，旨在帮助程序员提升技能，为面试和实际工作做好准备。本资源"leetcode答案-leetcode-practice:leetcode-练习"显然是一个LeetCode的...
LeetCode高级数据结构 - 前缀(Trie, 字典)树
Robin_812656252的博客
08-23 232
基本定义 有序的，用于统计、排序和存储字符串的数据结构 基本性质 1）关键字不直接保存在树的节点中，而是由根 -> 节点的路径确定关键字； 2） 利用字符串公共前缀，来减少存储空间，从而高效查询减少查询时间。 ADT 由一个字典树节点数组和一个boolean值构成； 节点数组大小由字典树涉及处理的字符集决定：只支持'a'->'z'则大小为26，支持ASCII字符为128（字符哈希） ...
分门别类刷leetcode——高级数据结构（字典树，前缀树，trie树，并查集，线段树）
一直走，不要回头
01-28 1778
Trie树(字典树、前缀树）的基础知识 字典树是一种有序的，用于统计、排序和存储字符串的数据结构，他与二叉查找树不同，关键字不是直接保存在节点中，而是由节点在树中的位置决定，每个节点代表了一个字符，从第一层孩子节点到中间的某个标记的节点代表了存储的字符串。 一个节点的所有子孙都有相同的前缀，而根节点对应空字符串。 一般情况下，不是所有的节点都有对应的字符串，只有叶子节点和部分内部节点进...
leetcode 刷题视频(10) - 高级数据结构
一个幽灵
10-25 234
高级数据结构 基础知识 trie树 又叫字典树、前缀树 （图中的红圈表示字符串结尾） 最为高效的字符串查找算法。 // 26 个字母 #define TRIE_MAX_CHAR_NUM 26 struct TrieNode { TrieNode *child[TRIE_MAX_CHAR_NUM]; bool is_end; TrieNode() : is_end(false) { for (auto &i : child) { i
LeetCode中涉及到的数据结构和算法的编程题总结
weixin_30295091的博客
05-14 309
1、链表 2、栈、队列、堆 3、贪心算法 4、递归回溯和分治 5、二叉树和图 6、二分查找和二叉查找树 7、哈希表和字符串 8、搜索 9、动态规划 转载于:https://www.cnblogs.com/BaoZiY/p/10685077.html...
leetcode答案-LeetCode-Python:LeetCode-Python
06-30
LeetCode 是一个知名的在线编程挑战平台，专注于提升程序员的算法和数据结构技能。它包含了大量面试常考问题，覆盖了从入门到高级的各种难度。Python 作为一种简洁且功能强大的编程语言，是很多开发者在解决 ...
leetcode答案-leetcode-java:leetcode-java
06-30
2. 数组与集合：理解数组和集合的区别，熟练运用ArrayList、LinkedList、HashMap等数据结构。 3. 控制流：掌握if-else、switch、for、while等语句的使用，以及三元运算符的应用。 4. 函数与方法：理解函数的参数传递...
leetcodepremium-Leetcode-Company-Questions-2020-2021:Leetcode公司问题按频率降序排
07-07
首先，我们要理解的是，LeetCode上的问题通常围绕算法和数据结构展开，这些问题涵盖了从基础到高级的各种难度，包括但不限于搜索、排序、图论、动态规划、回溯等。通过对这些问题的解答，开发者可以深入理解和熟练...
高级数据结构c++
08-26
线段树，splay，lct，后缀数组，后缀自动机，树链剖分的简单易懂的c++模板
高级数据结构总结
qq_46038405的博客
11-03 4113
高级数据结构总结 前期回顾：常用数据结构总结       仅仅掌握好它们是不足以应对大厂的算法面试的，很多大厂的算法面试题都涉及到了大数据、图论以及动态规划的数据等，这些问题如果只凭借常用数据结构来解决的话，是很难达到理想的时间和空间复杂度要求的。 1.1 高级数据结构 1.2 优先队列 / Priority Queue 1.3 图 / Graph 1.4 前缀树 / Trie 1.5 线段树 / Segment Tree 1.6 树状数组 /
leetcode与数据结构---310,802
OliverLYH的博客
08-17 621
leetcode与数据结构—310,802 题目描述 题802 在有向图中, 我们从某个节点和每个转向处开始, 沿着图的有向边走。 如果我们到达的节点是终点 (即它没有连出的有向边), 我们停止。 现在, 如果我们最后能走到终点，那么我们的起始节点是最终安全的。 更具体地说, 存在一个自然数 K, 无论选择从哪里开始行走, 我们走了不到 K 步后必能停止在一个终点。 哪些节点最终是...
C刷题：LeetCode常用算法框架及数据结构套路总结
来知晓的博客
08-17 681
本文把各分散的刷题博客总结，归纳整理成体系，汇总于此，刷题在精不在多，需能理解本质，做到举一反三，一通百通。欢迎盆友们讨论交流。
高级数据结构
Aiphis的博客
10-08 1551
内容简介编辑 高级数据结构林厚从主编的《高级数据结构》在基本数据结构的基础上，围绕一些常用的高级数据结构，结合大量实战例题，深入分析“数据结构是如何服务于算法的”。本书主要内容包括：哈希表、树与二叉树、优先队列与堆、并查集、线段树、树状数组、伸展树、Treap、AVL树、红—黑树、SBT、块状链表与块状树、后缀树与后缀数组、树链剖分与动态树等。 　　《高级数据结构》的适用对象包括：中学信息
数据结构算法 - LeetCode 刷题
z240336124的专栏
11-21 854
数据结构和算法的课程讲解，目前已告一段落，也算是完成了自己的一个心愿。因为去年听某同学抱怨过，说自己去爱奇艺面试，其他问题都答得不错，面试官问了一个哈夫曼算法的题没答出来，后来面试官很明确的说，我们还是想找一个会些算法基础的。 如果之前有学过数据结构和算法，建议大家不定时的去刷刷算法题，因为从面试的角度来讲，目前 BAT 和 TMD 等一线互联网企业或多或少都会有几个算法题，而对应届毕业生来说算法...
leetcode数据结构：栈和队列、堆、Set集合
weixin_42713642的博客
04-12 212
Set集合 【例】力扣第219题存在重复元素II：给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的 绝对值 至多为 k。 class Solution: def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool...
高级数据结构讲解与案例分析
Lansonli（蓝深李）的博客
04-12 1018
然而，仅仅掌握好它们不足以应付大厂的算法面试的。为了达到对时间和空间复杂度的理想要求，本节课探究高级数据结构，它们的实现要比那些常用的数据结构要复杂得多。其中重点介绍： 优先队列 图 前缀树 线段树 树状数组 掌握好高级数据结构的性质以及所适用的场合，在分析问题的时候回归本质，很多题目都能迎刃而解。 优先队列（Priority Que...
golang力扣leetcode 432.全O(1)的数据结构
清风
03-16 306
@TOC 432.全O(1)的数据结构 432.全O(1)的数据结构 题解 双向链表+哈希表（哈希表nodes 维护每个字符串当前所处的链表节点） 代码 package main import "container/list" type node struct { keys map[string]struct{} count int } type AllOne struct { *list.List nodes map[string]*list.Element } func Constr
leetcode-parse项目：实现LeetCode API抓取与算法学习便捷化
资源摘要信息:"LeetCode是一个著名的在线编程题库，它为编程人员提供了一个平台来练习和提高算法和数据结构方面的能力。LeetCode-parse是一个旨在抓取LeetCode API数据的项目，以便为LeetCode应用程序开发提供一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值