一文学会、精通trie树！

最新推荐文章于 2024-09-02 18:00:58 发布
最新推荐文章于 2024-09-02 18:00:58 发布
阅读量397 收藏 2
点赞数 3
分类专栏： 算法刷题 文章标签： trie C++ 数据结构 字典树
本文为博主原创文章，未经允许不得转载。如有问题，欢迎指正！
本文链接：https://blog.csdn.net/IAMLSL/article/details/115364163
版权

trie简介

一、trie是一种用于实现字符串快速检索的多叉树结构。可以类比普通链表或二叉树进行理解：普通链表的每个结点最多有1个后继结点、二叉树的每个结点有最多有2个后继结点（左右儿子），而每个trie结点可以有n个后继结点。n的取值由文本的字符串的组成决定，假设文本中只含小写或大写字母，则可令n等于26。每个trie的结点用于表示单个字符是否存在，通常将结点定义为指针类型，指针为空则表示当前结点表示的字符不存在，反之则存在。trie的结点中除了后继数组之外还可以存若干个数据，用于表示“当前字符是否为单词的结尾”、“有几个单词以当前字符为结尾”等信息。
链表、二叉树、trie树对比：

//链表
   struct ListNode {
      int val;
      ListNode *next;
      ListNode(int x) : val(x), next(NULL) {} //构造方法
   };
//二叉树
  struct TreeNode {
      int val;
      TreeNode *left;
      TreeNode *right;
      TreeNode(int x) : val(x), left(NULL), right(NULL) {}  //构造方法
  };
  
//trie树结点
struct TrieNode{
    public:
    bool Isword;    //表示“当前字符是否为单词的结尾”
    TrieNode *next[26];  //26个后继结点
};

二、一棵trie树由一个不表示字符的根结点确定，根结点是插入，查询的起点。假设trie树用于储存由小写字母构成的若干个字符串，那么就可以用后继数组next是否为空表示对应字符是否存在：next[0]，next[1],…,next[25]是否为空分别表示当前字符（假设当前字符存在）后面是否存在字符a,b,…,z。

三、将若干个字符串以根结点为起始插入trie树就实现了trie的创建。具体就是先让指针指向根结点，然后遍历插入的字符串，遍历到字符ch的时候，就判断当前结点的next[ch-‘a’]是否为空（是否存在），为空（不存在）就分配一个新节点，并将指针指向新结点。不为空（存在）就直接将指针指向next[ch-‘a’]。重复此操作直到遍历完字符串，则完成了这个字符串的插入。通常在插入完成后修改末尾结点的数据，用于表示“当前字符是否为单词的结尾”、“有几个单词以当前字符为结尾”等信息。
插入例子：
假设向trie树中加入单词app、apple、in、ink、inner、trie、true则trie树如下图所示，其中橙色结点代表该结点是单词的结尾。

在这里插入图片描述

插入函数写法：

//插入函数写法
    void insert(string word) {
    int len=word.size();
    TrieNode *pos=root;      //指针指向根结点
    for(int i=0;i<len;i++){
    int ch=word[i]-'a';     //获取当前字符对应“下标”
     
     //不存在则创建新结点（存在则不需创建，直接让pos往下指即可） 
    if(pos->next[ch]==NULL) pos->next[ch]=new TrieNode(); 
   
    pos=pos->next[ch];    //指针指向下一个结点
    }
    pos->Isword=true;      //标记此结点为一个单词的末尾
    }

四、查询（包括查单词、查前缀等）的做法和插入类似。（1）查前缀操作：先让指针指向根结点，然后遍历要查询的字符串，遍历到字符ch的时候，就判断当前结点的next[ch-‘a’]是否为空（是否存在），为空则代表不存在该单词，直接返回。若当前结点不为空则将指针指向下一个结点。直到将字符串遍历完，若中途没有空结点，则该字符串是trie树中某些单词的前缀。（2）查单词和查前缀的区别仅在于，查单词不仅要把要查的单词遍历完，还需要满足指针最后停留的结点代表一个单词的结尾。
拿上面的图来说，假如要查“ap”是否是trie树中某些单词的前缀，只需将“ap”遍历完并且中途没有空结点即可。但若要查“ap”是否是trie中的一个单词，则必须满足“p”处结点表示单词的结尾。

查单词、查前缀函数写法：

//查询字符串word是否是trie树中存在的一个单词
  bool search(string word) {
    int len=word.size();
    TrieNode *pos=root;      //指向根结点
    for(int i=0;i<len;i++){
    int ch=word[i]-'a';     
    if(!pos->next[ch]) return false;  //不存在单词中的字符则单词不存在
     pos=pos->next[ch];     //指向下一个结点
    }
    return pos->Isword;   //遍历完单词后，若此结点是单词结点则单词存在
    }

  

//查询prefix是否是trie中某些单词的前缀
bool startsWith(string prefix) {
    int len=prefix.size();
    TrieNode *pos=root;
    for(int i=0;i<len;i++){
    int ch=prefix[i]-'a';
    if(!pos->next[ch]) return false;  //中途有不存在的结点则说明prefix不是前缀
    pos=pos->next[ch];
    }
    return true;    //遍历完则表明prifix是前缀
    }

leetcode模板题

题目链接：leetcode 208. 实现 Trie (前缀树)

题目描述

Trie（发音类似 “try”）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。
请你实现 Trie 类：
Trie() 初始化前缀树对象。
void insert(String word) 向前缀树中插入字符串 word 。

boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。

boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ，返回 true ；否则，返回 false 。

示例：
输入
[“Trie”, “insert”, “search”, “search”, “startsWith”, “insert”, “search”]
[[], [“apple”], [“apple”], [“app”], [“app”], [“app”], [“app”]]
输出
[null, null, true, false, true, null, true]

解释
Trie trie = new Trie();
trie.insert(“apple”);
trie.search(“apple”); // 返回 True
trie.search(“app”); // 返回 False
trie.startsWith(“app”); // 返回 True
trie.insert(“app”);
trie.search(“app”); // 返回 True

C++代码

struct TrieNode{
    public:
    bool Isword;
    TrieNode *next[26];
};

class Trie {
    public:
     TrieNode *root=NULL;
     Trie() {
     root=new TrieNode();
     for(int i=0;i<26;i++){
       root->next[i]=NULL; 
    }
    }
    

    void insert(string word) {
    int len=word.size();
    TrieNode *pos=root;
    for(int i=0;i<len;i++){
    int ch=word[i]-'a';
    if(pos->next[ch]==NULL) pos->next[ch]=new TrieNode();
    pos=pos->next[ch];
    }
    pos->Isword=true;
    }


    bool search(string word) {
    int len=word.size();
    TrieNode *pos=root;
    for(int i=0;i<len;i++){
    int ch=word[i]-'a';
    if(!pos->next[ch]) return false;
     pos=pos->next[ch];
    }
    return pos->Isword;
    }
    

    bool startsWith(string prefix) {
    int len=prefix.size();
    TrieNode *pos=root;
    for(int i=0;i<len;i++){
    int ch=prefix[i]-'a';
    if(!pos->next[ch]) return false;
    pos=pos->next[ch];
    }
    return true;
    }

};

Java代码

class TrieNode{
   boolean isWord;
   TrieNode [] next;
    TrieNode(){
    isWord=false;
    next=new TrieNode[26];
    }
}

class Trie {

    TrieNode root;
    public Trie() {
    root=new TrieNode();   
    }

    public void insert(String word) {
    TrieNode pr=this.root;
    int n=word.length();
    for(int i=0;i<n;i++){
    char c=word.charAt(i); 
    if(pr.next[c-'a']==null){
    TrieNode node=new TrieNode();
    pr.next[c-'a']=node;    
    }
    pr=pr.next[c-'a'];
    }
    pr.isWord=true; 
    }
    
    public boolean search(String word) {
    TrieNode pr=this.root;
    int n=word.length();
    for(int i=0;i<n;i++){
    char c=word.charAt(i); 
    if(pr.next[c-'a']==null)
    return false;
    pr=pr.next[c-'a'];
    }
    return  pr.isWord; 
    }
   
    public boolean startsWith(String prefix) {
    TrieNode pr=this.root;
     int n=prefix.length();
    for(int i=0;i<n;i++){
    char c=prefix.charAt(i); 
    if(pr.next[c-'a']==null)
    return false;
    pr=pr.next[c-'a'];
    }
    return  true; 
    }
}

trie的数组实现方式

还是以存26个小写字母为例,定义二维数组trie[i][j]表示一个结点,其中j从0-25分别表示此结点代表的字符为a-z。而tire[i][j]的值相当于上面实现方法中的地址，令p=trie[i][j]就相当于pr=pr.next[c-‘a’]，trie[][]数组初始为0，trie[i][j]为0说明此结点不存在。在创建的过程中，给trie[i][j]分配一个id值表示其“地址”，以实现在trie树上的遍历。同时定义end[]数组标记对应结点是否是单词的结尾（或有几个单词以当前结点为结尾），如end[id]为1表示“地址id”处的字符是一个单词的结尾，其中id按插入的顺序依次编号。

例子：假设向trie树中依次加入单词ab、bc、abc、abc、efg,则trie树如下图所示，其中橙色结点代表该结点是单词的结尾,end[id]表示id处的字符是几个单词的结尾。

P2
插入函数写法：

int Isword[maxn];
   int id=0;   //节点编号
   
   void Insert(char *s){
   int len=strlen(s),p=0;
   for(int i=0;i<len;i++){
   
   //不存在则给结点分配一个编号id表示其“地址”
   if(!trie[p][s[i]-'a'])  trie[p][s[i]-'a']=++id;  
   p=trie[p][s[i]-'a'];     //p指向新的节点
   }
   end[p]++;      //记录以“地址p”为结尾的单词个数
   }

牛客网trie树题目一

题目描述

题目链接：牛客网 前缀统计
给定N个字符串 S 1 , S 2 , . . . , S N ​ S_{1},S_{2},...,S_{N}​ S1​,S2​,...,SN​​，接下来进行 M M M次询问，每次询问给定一个字符串 T T T，求 S 1 ∼ S N S_{1}∼S_{N} S1​∼SN​中有多少个字符串是 T T T的前缀。输入字符串的总长度不超过 1 0 6 10^6 106，仅包含小写字母。
输入描述:
第一行两个整数 N ， M N，M N，M。接下来 N N N行每行一个字符串 S i Si Si。接下来M行每行一个字符串表示询问。
输出描述:
对于每个询问，输出一个整数表示答案
示例1

输入
3 2
ab
bc
abc
abc
efg

输出
2
0

分析：

题意是求trie树中有几个单词是字符串T的前缀。只需将单词都插入trie树，然后查询T的时候直接累加“路径”上的end[id]即可。此题的样例图就是上面那个>_<。

C++代码：

#include<cstdio>
#include<cstring>
   const int maxn=1e6+100;
   int trie[maxn][30];
   int end[maxn];
   int id=0;   //节点编号
   void Insert(char *s){
   int len=strlen(s),p=0;
   for(int i=0;i<len;i++){
   if(!trie[p][s[i]-'a'])  trie[p][s[i]-'a']=++id;  //不存在则创建并给一个新的编号
   p=trie[p][s[i]-'a'];     //p指向新的节点
   }
   end[p]++;      //以p结尾的单词数加1
   }
   int IsPrefix(char *s){
   int len=strlen(s),p=0,sum=0;
   for(int i=0;i<len;i++){
   if(!trie[p][s[i]-'a']) return sum;   //如果已经没有节点，直接返回sum
   p=trie[p][s[i]-'a'];   //p指向新的节点
   sum+=end[p];       //加上以当前节点为结尾字母单词的个数
   }
   return sum;
   }
   int main(){
   int N,M;
   scanf("%d%d",&N,&M);
   char S[maxn];       
   while(N--){ 
   scanf("%s",&S);
   Insert(S);
   }
   int res=0;
   char T[maxn];     
   while(M--){   
   scanf("%s",&T);
   printf("%d\n",IsPrefix(T));
   }
   return 0;
   }

牛客网trie树题目二

题目描述

题目链接：The XOR Largest Pair
在给定的 N 个整数 A1，A2……AN 中选出两个进行 xor（异或）运算，得到的结果最大是多少？

输入格式
第一行输入一个整数 N。

第二行输入 N 个整数 A1～AN。

输出格式
输出一个整数表示答案。

数据范围
1 ≤ N ≤ 1 0 5 , 0 ≤ A i < 2 31 1≤N≤10^5,0≤Ai<2^{31} 1≤N≤105,0≤Ai<231

输入样例：
3
1 2 3
输出样例：
3

分析：

可直接枚举两个数的异或值，选出最大的即可，但是此做法时间复杂度为 o ( n 2 ) o(n^2) o(n2)，此数据规模下将会超时。

trie树优化：
问题转化：已知数 x x x和数列 a 1 , . . . , a n a_{1},...,a_{n} a1​,...,an​,如何找出数列中的一个数使其和 x x x的异或值最大？异或是“二进制表示下的按位操作”，可把数列 a 1 , . . . , a n a_{1},...,a_{n} a1​,...,an​按二进制表示下的形式从高位到低位依次插入trie树，再把 x x x当作要查询的数向下查询即可。熟悉异或运算的话就会知道0^1=1, 1^0=1 , 0^0=0 ,1^1=0。即对于0，1两个状态的异或，不同为1，相同为0。假如 x x x的当前位为1就选下一位表示0的路径，假如 x x x的当前位为0就选下一位表示1的路径，这样当前位就不会被消去，异或值中就会保留 2 i 2^i 2i,（ i i i是当前的位数），由于是把二进制从高位到低位插入trie树中，所以从根结点开始不断选择和当前位相异的路径走下去，必定可以得到最大值（从高位到低位选不同的路径可以保证尽量不让高位被抵消）。注意，若当前只有一个路径，就只能选择该路径走。

假如往trie树里插入1,3,7,10,13,14,15则得到如下图所示trie树：

在这里插入图片描述

假如在上面的trie树中分别查询哪个数和8（二进制为1000）、3（二进制为0011）的异或值最大，则查询路径即结果如下图所示（8和7异或可得最大值，3和13异或可得最大值）：
在这里插入图片描述

C++代码：

#include<iostream>
#include<cstring>
using namespace std;
const int N=1e5+100;
int trie[30*N][2],a[N];
int id=0;
void Insert(int x){
    int p=0;
    for(int i=30;i>=0;i--){
        int ch=x>>i&1; //获取x二进制的第i位值
        if(!trie[p][ch]){
            trie[p][ch]=++id;  //如果没有结点则创建新结点
        }
        p=trie[p][ch];
    }
}

//查询x和数组中某数所能产生的最大异或值
int search(int x){
    int p=0,sum=0;
    for(int i=30;i>=0;i--){
        int ch=x>>i&1;
        
        //如果存在与当前位不同的路径，就选这条路径走
        if(trie[p][!ch]){  
           sum+=(1<<i);   //累加没有被抵消的权值
           p=trie[p][!ch];
        }
        else{
          //由于权值被抵消，省略sum+=0
            p=trie[p][ch];
        }
    }
    return sum;
}
int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
     //将数组中的数都插入trie
        Insert(a[i]);
    }
    
    int res=0;
    for(int i=1;i<=n;i++){
    
    //查询a[i]和数组中某个数异或能够产生的最大异或值，并更新答案res
        res=max(res,search(a[i])); 
        
    }
    cout<<res<<endl;
    return 0;
}

牛客网trie树题目三

题目描述

题目链接：The XOR-longest Path
给定一棵n个点的带权树，求树上最长的异或和路径。

输入描述:
第一行一个整数n，接下来n-1行每行三个整数u,v,w，表示u,v之间有一条长度为w的边。
输出描述:
输出一行一个整数，表示答案。
示例1
输入

4
1 2 3
2 3 4
2 4 6

输出

7

说明
最长的异或和路径是 1 → 2 → 3 1→2→3 1→2→3，它的长度是 3 ⨁ 4 = 7 3⨁4=7 3⨁4=7。
注意：结点下标从1开始到N。
注：x⨁y表示x与y按位异或。

备注:

对于100%的数据， 1 ≤ n ≤ 1 0 5 , 1 ≤ u , v ≤ n , 0 ≤ w < 2 31 1≤n≤10^5,1≤u,v≤n,0≤w<2^{31} 1≤n≤105,1≤u,v≤n,0≤w<231

trie解法：

  • 此处存在一个规律：连接结点 x x x和结点 y y y的异或和路径的长度等于 “ x x x和根节点的异或和路径长度”与“ y y y和根节点的异或和路径长度”的异或值。
    如下图中的例子：
    结点6和结点7的异或和路径长度为 7 ^ 4 ^ 3 ，结点6和根结点1的异或和路径长度为7 ^ 4 ^ 6 ,结点7和根结点1的异或和路径长度为3 ^ 6 。故“结点6和根节点的异或和路径长度”与“结点7和根节点的异或和路径长度”的异或值为（7 ^ 4 ^ 6）^(3 ^ 6)。而 （7 ^ 4 ^ 6）^ (3 ^ 6)=7 ^ 4 ^ 3 。
    熟悉异或的性质不难理解上述规律：由于两个相同的数相异或得0，而两个结点的到根结点的异或和路径相异或正好抵消了那段重合的异或值。
    在这里插入图片描述
  • 基于以上规律，可以得到解决方法：dfs获取每个结点与根结点的异或和路径长度，然后从这些路径长度中找出两个路径长度使其异或值最大即可。上一题已经给出了在一串数中找两个数的最大异或和，故此处只需将每个结点与根结点的异或和路径长度像上一题一样插入trie中，然后查询一遍即可。

C++代码：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=1e5+100;
int trie[35*N][2],id=0;
void Insert(int x){
    int p=0;
    for(int i=30;i>=0;i--){
        int ch=x>>i&1; //获取x二进制的第i位值
        if(!trie[p][ch]){
            trie[p][ch]=++id;  //如果没有结点则创建新结点
        }
        p=trie[p][ch];
    }
}

//查询x和数组中某数所能产生的最大异或值
int search(int x){
    int p=0,sum=0;
    for(int i=30;i>=0;i--){
        int ch=x>>i&1;
        
        //如果存在与当前位不同的路径，就选这条路径走
        if(trie[p][!ch]){  
           sum+=(1<<i);   //累加没有被抵消的权值
           p=trie[p][!ch];
        }
        else{
          //由于权值被抵消，省略sum+=0
            p=trie[p][ch];
        }
    }
    return sum;
}


//链式前向星存图
struct egde{
    int u;
    int v;
    int w;
    int next;
}e[2*N];
int head[N],vis[N],d[N],cnt=0;
void Insert(int u,int v,int w){
    cnt++;
    e[cnt].u=u;
    e[cnt].v=v;
    e[cnt].w=w;
    e[cnt].next=head[u];
    head[u]=cnt;
}

//dfs遍历的过程中获取每个结点与根结点异或和路径长度
void dfs(int u){
    vis[u]=1;
    for(int i=head[u];i>=0;i=e[i].next){
        if(!vis[e[i].v]){
            d[e[i].v]=d[u]^e[i].w;
            dfs(e[i].v);
        }
    }
}

int main(){
    memset(head,-1,sizeof(head));
    memset(vis,0,sizeof(vis));
    int n;
    scanf("%d",&n);
    int u,v,w;
    for(int i=1;i<=n-1;i++){
        scanf("%d%d%d",&u,&v,&w);
        Insert(u,v,w);
        Insert(v,u,w);
    }
    dfs(1);
    
    for(int i=1;i<=n;i++) Insert(d[i]);
    
    int res=0;
    for(int i=1;i<=n;i++){
    
    //查询d[i]和数组中某个数异或能够产生的最大异或值，并更新答案res
        res=max(res,search(d[i])); 
        
    }
    
    printf("%d\n",res);
    return 0;
}
准图灵奖得主
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Trie树（字典树）C++详解
m0_54615144的博客
10-05 627
字典树是一个用来快速查找和存储字符串集合的数据结构。
Trie树
壮少Bryant的博客
09-03 333
1. Trie树 Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。 Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。它有3个基本性质： 根节点不包含字符，除根
trie字典树使用
厉兵秣码
08-01 98
参考一下文章，写代码自己记录下 数据结构与算法：字典树（前缀树） 字典树节点 class TrieNode { //表示以当前单词结尾的单词数量。 int count; //表示以当前节点之前（包括当前节点）的字符串为前缀的字符串个数 // 表示以该处节点之前的字符串为前缀的单词数量 int prefix; TrieNode[] nextNode = new TrieNode[26]; public TrieNode() { coun
Trie树（字典树&前缀树）
小朱小朱绝不认输的博客
05-16 2064
Trie树的学习 文章目录1. Trie树的基本知识2. Trie树的实现2.1 二维数组实现2.2 TrieNode实现2.3 方法对比2.4 问题分析 1. Trie树的基本知识 Trie 树（又叫「前缀树」或「字典树」）是一种用于快速查询「某个字符串/字符前缀」是否存在的数据结构。 Trie 树的本质，就是利用字符串之间的公共前缀，将重复的前缀合并在一起。 Trie树是一种哈希树的变种。 典型应用：用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。 优点：最大限度
Trie树(字典树)的介绍及Java实现
08-31
Trie树，也被称为字典树或前缀树，是一种数据结构，主要用于高效地存储和检索字符串集合中的数据。在Trie树中，每个节点代表一个字符串的前缀，从根节点到某个节点的路径上的字符序列构成了该节点对应的字符串。这种...
PHP字典树(Trie树)定义与实现方法示例
10-19
字典树，又称为Trie树或前缀树，是一种高效的数据结构，主要用于存储和检索具有公共前缀的字符串。这种数据结构能够大大减少字符串比较的次数，提高查询效率，尤其在处理大量字符串时效果显著。在搜索引擎系统中，...
多分枝trie树路由查找算法研究
04-16
为了解决路由器报文转发中路由查找速度慢的瓶颈问题，在分析了路由器中广泛使用的各种典型IP路由算法的基础上，提出一种基于多分枝trie树的改进路由查找算法。在多分枝trie树中取消前缀查找，组成一个大的中间结点。...
Trie树_字典树(字符串排序)简介及实现
10-26
Trie树，又称字典树、单词查找树，是一种用于处理字符串相关问题的高效数据结构。其核心思想是通过空间换时间，利用字符串的公共前缀来节约存储空间，并减少无谓的字符串比较，从而达到快速查找、插入和删除字符串的...
树、二叉树
2301_79909332的博客
08-30 525
1、满二叉树：满二叉树是一种特殊的二叉树，其中每个层级的节点数都是最大值，即每个层级都是完全填充的。深度： 从根节点出发到达节点的分支节点个数称为该节点的深度。高度：从叶子节点出发到该节点最大的节点个数称为该节点的高度。树的高度：整个树形结构中高度最高的节点的高度称为树的高度。树的深度：整个树形结构中深度最深的节点的深度称为树的深度。3、二叉树特点：叶子节点、只有左孩子、只有右孩子、左右孩子都有。树的层数 == 树的高度 == 树的深度。3.叶子节点：没有后继的节点。节点的度： 叶子节点度数为0。
9/2 pandas数据结构介绍
最新发布
m0_58285219的博客
09-02 672
1.对于Series ：当对象相加时，如果存在不同的索引对，则结果的索引是所有索引的并集，对于不重叠的标签，会导致缺失值 obj1 + obj2。注：在重构时，标签只含新的指定序列中的标签，新的和原来的匹配则保留，不匹配则删除原来的，添加新的。2.对于DataFrame：会将行和列的索引同时进行匹配，得到的行列索引是所有索引的并集，不重叠的标签，会导致缺失值。data.drop(["a”，“b"]，axis="index或columns"）担当索引不为整数索引时，可用data[-1]来提取最后一个数据。
【数据结构】队列(Queue)
xiaochuan_bsj的博客
08-28 907
数组，双链表实现队列，附完整代码
【数据结构】-----哈希
m0_73470633的博客
08-29 1611
一文看懂哈希结构！
数据结构-单链表-详解-1
2401_86587256的博客
08-30 1647
数据结构初阶部分，单链表的详解-1
数据结构-二叉树的遍历和线索二叉树
yandadzf的博客
08-30 409
先序遍历：根 -> 左 -> 右中序遍历：左 -> 根 -> 右后序遍历：左 -> 右 -> 根。
滑动窗口系列(不定长滑动窗口长度) 9/2
2301_78191305的博客
09-02 808
移动right的时候，需要更新costK，costK=(nums[right]-nums[right-1])*(right-left);逆向思维就是：题目中是否存在一段子串满足字符出现最多的次数为:count[0]-k,count[1]-k,count[2]-k。每次遍历到一个字符，就将出现的次数-1(还可以出现多少次)，如果出现<0的情况，左边界就要改变了。每次操作的时候，移除左边和右边的元素，使得移除元素之和=x。给定一个数组nums,求子数组中删除k个元素后，所有元素都相等，返回相同元素的最大个数。
Java-数据结构-ArrayLis与线性表 (๑╹◡╹)ﾉ“““
2303_80388948的博客
08-30 1521
我们可以看到这个图片的最左边呢就是我们List，这个List继承了 Collection 接口，Collection接口又继承了 Iterable，接口，所以我们的 List 接口就有了这两个接口的所有方法。在我们站在数据结构的角度来看呢，List 接口就是一个线性表，就是n个具有相同类型的元素的有限序列 ，在这个序列上可以进行增删查改的操作。注意我们的List是一个接口，不能实例化，要是使用的话，只能去实例化List的实现类。
数据结构(Java)实现：栈和队列
li_wj6的博客
08-29 1283
一篇文章，带你通过Java学习数据结构中的栈和队列。
数据结构——二叉树
m0_61965705的博客
08-30 1034
/二叉树节点类型int No;}TreeNode;
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值