2. 程式人生 > >字典樹(Trie)的學習筆記

字典樹(Trie)的學習筆記

阿新 • • 發佈：2018-11-16

按照一本通往下學，學到吐血了。。。

例題1

字典樹模板題嗎。

先講講字典樹：

在這裡插入圖片描述

給出程式碼（太簡單了。。。）！

#include<cstdio>
#include<cstring>
using  namespace  std;
struct  trie
{
    int  a[10],v;
    //a代表0~9的兒子的編號，有則為這個節點的編號，沒有就是0。
    //v是附加權值，代表每個節點被經過的次數。
}tr[200000];int  trlen;//多少節點
char  st[11000][20];int  n;
void  add(char  ss[])
{
    int  len=strlen(ss+1),root=0;//root代表根節點
    for(int  i=1;i<=len;i++)
    {
        int  k=ss[i]-'0';//計算是哪個兒子。。。
        if(tr[root].a[k]==0)tr[root].a[k]=++trlen;//新增新節點
        root=tr[root].a[k];tr[root].v++;//給這個節點加一次走過的標記
    }
}
int  find(char  ss[])
{
    int  len=strlen(ss+1),root=0;//root代表根節點
    for(int  i=1;i<=len;i++)//找到這個字串最底下的節點編號
    {
        int  k=ss[i]-'0';
        root=tr[root].a[k];
    }
    return  tr[root].v-1;//被經過兩次代表這個字串是某個字串的字首。
}
int  main()
{
    int  T;scanf("%d",&T);
    while(T--)
    {
        memset(tr,0,sizeof(tr));trlen=0;//初始化
        scanf("%d",&n);
        for(int  i=1;i<=n;i++)//新增
        {
            scanf("%s",st[i]+1);
            add(st[i]);
        }
        bool  bk=false;
        for(int  i=1;i<=n;i++)
        {
            if(find(st[i]))//發現答案
            {
                bk=true;
                printf("NO\n");//輸出
                break;
            }
        }
        if(bk==false)printf("YES\n");//同樣是輸出。
    }
    return  0;
}

例題二

我們發現只要把每個數字轉成31位二進位制，然後，一個個插入字典樹，在插入之前，我們計算一下當前的數與哪個數的異或值最大，並記錄一下。
至於如何找，只需要，我們只需要每次走與當前二進位制位數不一樣的數字就行了，看程式碼還挺好理解的（find函式）

#include<cstdio>
#include<cstring>
using  namespace  std;
struct  node
{
    int  a[2],v;//v是附加權值，代表這個二進位制數是多少
}tr[6100000];int  trlen;
char  st[40];
int  n,ans;
void  lintoto(int  x)//將x轉成二進位制數
{
    memset(st,0,sizeof(st));
    int  len=0;
    while(x)
    {
        st[++len]=(x&1);//相當於x%2。
        x>>=1;//除於2
    }
}
void  add(char  ss[],int  id)
{
    int  len=31,root=0;
    for(int  i=len;i>=1;i--)//由於當時存二進位制是倒著存的，現在也要倒著搜
    {
        int  k=ss[i];
        if(!tr[root].a[k])tr[root].a[k]=++trlen;//新建節點
        root=tr[root].a[k];
    }
    tr[root].v=id;//新增附加權值
}
inline  int  mymax(int  x,int  y){return  x>y?x:y;}
inline  int  find(char  ss[],int  id)
{
    int  root=0,len=31;
    for(int  i=len;i>=1;i--)
    {
        int  k=ss[i];
        if(tr[root].a[k^1])root=tr[root].a[k^1];//走相反的地方
        else  root=tr[root].a[k];//不存在，走相同的地方。
    }
    return  (tr[root].v^id);
}
int  main()
{
    scanf("%d",&n);
    for(int  i=1;i<=n;i++)
    {
        int  x;scanf("%d",&x);
        lintoto(x);//轉成二進位制
        if(i!=1)ans=mymax(ans,find(st,x));//更新新的答案
        add(st,x);//新增
    }
    printf("%d\n",ans);
    return  0;
}

例題三

先證明異或符合交換律、結合律。

首先，異或的過程中：(1,0),(0,1),(0,0)都是消掉一個0，而(1,1)是消掉一個1。

我們可以發現，多次異或就是看所有數二進位制的每一位的1的個數，奇數就為1，偶數為0，而你調換順序的話，個數並沒有變，所以滿足交換律與結合律。

那麼這道題，我們設\(sst_{i}=a_{1}⨁a_{2}⨁a_{3}⨁a_{4}...⨁a_{i}\)，那麼，求區間最大，我們可以發現：

\(a_{l}⨁a_{l+1}⨁...⨁a_{r}=(a_{1}⨁a_{2}⨁a_{3}⨁...⨁a_{r})⨁(a_{1}⨁a_{2}⨁a_{3}⨁...⨁a_{l-1})=sst_{r}⨁sst_{l-1}\)


也就是說，我們只要求出在1~r-1區間內能異或\(sst_{r}\)的最大值，也就是上面那道題，設\(ll_{i}=\) 在1~i區間內的一個區間最大異或值，\(ll_{i}=max(ll_{i-1},以i為結尾的最大異或區間)\)。

再設一個\(rr_{i}=\) 在i~n區間內的一個區間最大異或值，\(rr_{i}=max(rr_{i+1},以i為開頭的最大異或區間)\)。

求出最大的\(ll_{i-1}+rr_{i}\)

#include<cstdio>
#include<cstring>
using  namespace  std;
struct  trie
{
    int  a[2],v;
}tr[9100000];int  trlen;//字典樹
char  st[210];
int  sst[410000],n,ll[410000],rr[410000],ans;//陣列
void  intto(int  x)//像上次那樣。。。
{
    memset(st,0,sizeof(st));
    int  len=0;
    while(x)
    {
        st[++len]=(x&1);//x%2
        x>>=1;//x/=2
    }
}
void  add(char  ss[],int  id)//新增
{
    int  len=31,root=0;
    for(int  i=len;i>=1;i--)
    {
        int  k=ss[i];
        if(!tr[root].a[k])tr[root].a[k]=++trlen;
        root=tr[root].a[k];
    }
    tr[root].v=id;
}
int  find(char  ss[],int  id)//尋找
{
    int  len=31,root=0;
    for(int  i=len;i>=1;i--)
    {
        int  k=ss[i];
        if(tr[root].a[k^1])root=tr[root].a[k^1];
        else  root=tr[root].a[k];
    }
    return  (tr[root].v^id);//返回異或值
}
inline  int  getsum(int  x,int  y){return  sst[y]^sst[x-1];}//[x,y]區間的異或值
inline  int  mymax(int  x,int  y){return  x>y?x:y;}//最大值
int  main()
{
    scanf("%d",&n);
    intto(0);
    add(st,0);//將0新增
    for(int  i=1;i<=n;i++)
    {
        scanf("%d",&sst[i]);sst[i]^=sst[i-1];
        intto(sst[i]);//二進位制
        ll[i]=mymax(find(st,sst[i]),ll[i-1]);//更新
        add(st,sst[i]);//新增
    }
    memset(tr,0,sizeof(tr));trlen=0;
    intto(0);
    add(st,0);
    for(int  i=n;i>=1;i--)
    {
        intto(getsum(i,n));
        rr[i]=mymax(rr[i-1],find(st,getsum(i,n)));
        add(st,getsum(i,n));
    }//反著來一遍
    for(int  i=2;i<=n;i++)ans=mymax(ans,ll[i-1]+rr[i]);//統計答案
    printf("%d\n",ans);
    return  0;
}

練習一

跟例題一 一樣。。。只不過處理方式出了點問題。

#include<cstdio>
#include<cstring>
#include<cstdlib>
using  namespace  std;
struct  node
{
    int  a[10],v;
}tr[2100];int  trlen;//字典樹
char  st[20];
void  add(char  ss[])//打得不能再順手的新增。。。
{
    int  len=strlen(ss+1),root=0;
    for(int  i=1;i<=len;i++)
    {
        int  k=ss[i]-'0';
        if(!tr[root].a[k])tr[root].a[k]=++trlen;
        root=tr[root].a[k];
    }
    tr[root].v=1;
}
bool  find(char  ss[])//每天都在變。。。
{
    int  len=strlen(ss+1),root=0;
    for(int  i=1;i<=len;i++)
    {
        int  k=ss[i]-'0';
        if(!tr[root].a[k])return  false;//不存在節點？返回
        root=tr[root].a[k];
        if(tr[root].v==1)return  true;//存在，返回
    }
    return  false;
}
int  main()
{
    int  T=0;
    while(scanf("%s",st+1)!=EOF)
    {
        T++;
        memset(tr,0,sizeof(tr));trlen=0;//初始化
        bool  bk=false;
        while(1)
        {
            int  len=strlen(st+1);
            if(len==1  &&  st[1]=='9')break;//退出
            if(find(st))bk=true;//尋找
            add(st);//新增
            scanf("%s",st+1);//輸入
        }
        if(bk==true)printf("Set %d is not immediately decodable\n",T);
        else  printf("Set %d is immediately decodable\n",T);
    }
    return  0;
}

練習二

將字典建個字典樹，然後類似遞推思想瞎搞。。。

提示：建一個d陣列代表這一段在前i位能否被表達。

#include<cstdio>
#include<cstring>
using  namespace  std;
struct  node
{
    int  a[26],v;
}tr[51000];int  trlen;//字典樹
char  st[2100000];//字串
int  n,m;
char  d[2100000];//d陣列
void  add(char  ss[])
{
    int  len=strlen(st+1),root=0;
    for(int  i=1;i<=len;i++)
    {
        int  k=st[i]-'a';
        if(!tr[root].a[k])tr[root].a[k]=++trlen;
        root=tr[root].a[k];
    }
    tr[root].v=1;
}
bool  find(int  l,int  r)//匹配l~r區間
{
    int  root=0;
    for(int  i=l;i<=r;i++)
    {
        int  k=st[i]-'a';
        if(!tr[root].a[k])return  false;
        root=tr[root].a[k];
    }
    return  tr[root].v;
}
inline  int  mymax(int  x,int  y){return  x>y?x:y;}
int  jie;
int  main()
{
    scanf("%d%d",&n,&m);
    for(int  i=1;i<=n;i++)
    {
        scanf("%s",st+1);
        add(st);
        jie=mymax(jie,strlen(st+1));//最長的單詞
    }
    for(int  kkk=1;kkk<=m;kkk++)
    {
        memset(d,0,sizeof(d));d[0]=1;//初始化
        scanf("%s",st+1);
        int  len=strlen(st+1);
        for(int  i=1;i<=len;i++)
        {
            for(int  j=mymax(1,i-jie+1);j<=i;j++)
            {
                if(d[j-1]==1  &&  find(j,i))//如果前j-1位已經匹配成功，那麼判斷當前能否匹配成功
                {
                    d[i]=1;
                    break;
                }
            }
        }
        int  ans=0;
        for(int  i=len;i>=1;i--)//統計
        {
            if(d[i]==1)
            {
                ans=i;break;
            }
        }
        printf("%d\n",ans);
    }
    return  0;
}

練習三

建立資訊為字典樹，兩個附加權值，代表被經過的次數和作為結尾的次數。

那密碼進行統計。。。

怎麼統計自己想或看程式碼

#include<cstdio>
#include<cstring>
using  namespace  std;
struct  trie
{
    int  a[2],v1,v2;//兩個附加權值，v1代表被經過次數，v2代表被作為結尾的次數
}tr[610000];int  trlen;//字典樹
char  st[510000];//字串
int  n,m;
void  add(int  len)//新增
{
    int  root=0;
    for(int  i=1;i<=len;i++)
    {
        int  k=st[i];
        if(!tr[root].a[k])tr[root].a[k]=++trlen;
        root=tr[root].a[k];tr[root].v1++;//經過一次
    }
    tr[root].v2++;//作為結尾加一
}
int  find(int  len)
{
    int  root=0,ans=0;
    for(int  i=1;i<=len;i++)
    {
        int  k=st[i];
        if(!tr[root].a[k])return  ans;
        root=tr[root].a[k];ans+=tr[root].v2;//有多少是他的字首
    }
    ans+=tr[root].v1-tr[root].v2;//他是多少字串的字尾
    return  ans;
}
int  main()
{
    scanf("%d%d",&n,&m);
    for(int  i=1;i<=n;i++)
    {
        int  len;scanf("%d",&len);
        for(int  j=1;j<=len;j++)scanf("%d",&st[j]);//輸入字串
        add(len);//新增
    }
    for(int  i=1;i<=m;i++)
    {
        int  len;scanf("%d",&len);
        for(int  j=1;j<=len;j++)scanf("%d",&st[j]);//輸入字串
        printf("%d\n",find(len));//尋找
    }
    return  0;
}

練習四

這道題目QAQ。

首先，我們知道，長度為s1的字串a1，長度為s2的字串a2，如果\(s1<s2\)並且a1與a2都是a3的字尾，那麼a1是a2的字尾。

將所有字串翻轉，建一個字典樹，然後建一顆樹，當\(i\)->\(j\)僅當，\(a_{i}\)是\(a_{j}\)的最大字首。

然後，DFS新樹，每次進入沒進過且節點最少的樹就行了。

（如果直接在字典樹上跑的話，子樹大小會錯亂，導致每次進的不是節點最小的樹）

這道題還是有點難的，因為用到了一點貪心思想。

#include<cstdio>
#include<cstring>
#include<algorithm>
using  namespace  std;
char  st[520000];
int  n;
bool  bol[110000];
struct  trie//字典樹
{
    int  a[26],v;
}tr1[610000];int  trlen1;
struct  node//新建的樹
{
    int  y,next;
}tr2[110000];int  trlen2,last[110000],size[110000];//用邊目錄儲存
void  ins(int  x,int  y)//新建一條邊
{
    trlen2++;
    tr2[trlen2].y=y;tr2[trlen2].next=last[x];last[x]=trlen2;
}
void  add(int  id)//新增
{
    int  root=0,len=strlen(st+1);
    for(int  i=len;i>=1;i--)//字串翻轉
    {
        int  k=st[i]-'a';
        if(!tr1[root].a[k])tr1[root].a[k]=++trlen1;
        root=tr1[root].a[k];
    }
    tr1[root].v=id;
}
int  dfss(int  x,int  fa)//遍歷字典樹，建新樹，fa是離他最近的有權的祖先
{
    int  ans=0;//代表子樹大小
    for(int  i=0;i<=25;i++)
    {
        if(tr1[x].a[i])
        {
            if(tr1[x].v)ans+=dfss(tr1[x].a[i],tr1[x].v);//本身是一個節點
            else  ans+=dfss(tr1[x].a[i],fa);//本身不是一個節點，只是一箇中轉站
        }
    }
    if(tr1[x].v)//本身是一個節點
    {
        ins(fa,tr1[x].v);//連向父親
        ans++;size[tr1[x].v]=ans;//繼承大小
    }
    return  ans;//返回目前的子樹大小
}
long  long  anss;
int  times,lis[110000],listlen;
bool  cmp(int  x,int  y){return  size[x]<size[y];}
void  dfs(int  x,int  nowss)
{
    int  now=++times;
    int  l=listlen+1,r;
    for(int  k=last[x];k;k=tr2[k].next)lis[++listlen]=tr2[k].y;//處理list
    r=listlen;
    if(l<=r)sort(lis+l,lis+1+r,cmp);//排序是排[l,r) 
    else  return  ;//沒有子樹 
    for(int  i=l;i<=r;i++)
    {
        anss+=(times+1)-now;//統計答案 
        dfs(lis[i],now);//繼續遞迴 
    }
}
int  main()
{
    scanf("%d",&n);
    for(int  i=1;i<=n;i++)
    {
        scanf("%s",st+1);
        add(i);
    }//新增所有字串
    dfss(0,0);//建樹 
    dfs(0,0);//處理答案 
    printf("%lld\n",anss);//輸出 
    return  0;
}

練習五

這道題，我一開始想得太複雜了。。。

我一開始想到的是一條路徑上，起點是l，終點是r，然後還涉及到求LCA，然後就十分複雜。。。

然後膜了一波題解，發現自己就是個弱智。。。

設\(sum[i]=(1->i)\)的權值異或值 ，那麼一條路徑上的異或權值和就是\(sum[l]\)^\(sum[j]\)，然後就是求一個數組中求與\(sum[i]\)異或值最大的數，其實就是例題了，根本不用在樹上進行特別麻煩的遍歷，或者是過程很麻煩的樹上遞迴，是不是很巧妙？好吧，我承認就是我沒有想到然後就亂膜。。。

#include<cstdio>
#include<cstring>
using  namespace  std;
struct  node
{
    int  y,next,c;
}a[210000];int  last[110000],alen;
int  sum[110000];//邊目錄 
void  ins(int  x,int  y,int  c)
{
    alen++;
    a[alen].y=y;a[alen].c=c;a[alen].next=last[x];last[x]=alen;
}
void  dfs(int  x,int  fa)
{
    for(int  k=last[x];k;k=a[k].next)
    {
        int  y=a[k].y;
        if(y!=fa)//不是他的父親 
        {
            sum[y]=sum[x]^a[k].c;//處理sum陣列 
            dfs(y,x);//繼續遞迴 
        }
    }
}
struct  trie
{
    int  a[2],v;
}tr[4100000];int  trlen;//字典樹 
char  st[40];//儲存二進位制的陣列。 
void  intoo(int  x)
{
    memset(st,0,sizeof(st));//初始化 
    int  len=0;
    while(x)
    {
        st[++len]=(x&1);//x%2
        x>>=1;//x/=2
    }
}
void  add(int  id)//新增 
{
    int  len=31,root=0;
    for(int  i=len;i>=1;i--)//新增二進位制要注意的 
    {
        int   k=st[i];
        if(!tr[root].a[k])tr[root].a[k]=++trlen;
        root=tr[root].a[k];
    }
    tr[root].v=id;
}
int  find(int  id)
{
    if(trlen==0)return  0;//判斷目前字典樹是否有節點 
    int  len=31,root=0;
    for(int  i=len;i>=1;i--)
    {
        int  k=st[i];
        if(tr[root].a[k^1])root=tr[root].a[k^1];//貪心找異或值最大 
        else  root=tr[root].a[k];
    }
    return  (id^tr[root].v);//給出結果 
}
int  n;
inline  int  mymax(int  x,int  y){return  x>y?x:y;}//找最大值 
int  main()
{
    scanf("%d",&n);
    for(int  i=1;i<n;i++)
    {
        int  x,y,c;scanf("%d%d%d",&x,&y,&c);
        ins(x,y,c);ins(y,x,c);
    }
    dfs(1,0);//預設1為根，處理sum陣列 
    int  ans=0;
    for(int  i=1;i<=n;i++)//例題的做法 
    {
        intoo(sum[i]);
        ans=mymax(ans,find(sum[i]));
        add(sum[i]);
    }
    printf("%d\n",ans);
    return  0;
}

終於寫完了。。。

相關推薦

字典樹(Trie)的學習筆記

按照一本通往下學，學到吐血了。。。 例題1 字典樹模板題嗎。 先講講字典樹： 給出程式碼（太簡單了。。。）！ #include<cstdio> #include<cstring> using namespace std; struct trie { int

【數據結構】前綴樹/字典樹/Trie

splay 多個 結果 順序 using node 提示 額外 join 【前綴樹】 　　用來保存一個映射（通常情況下 key 為字符串 value 為字符串所代表的信息） 　　例如：一個單詞集合 words = { apple， cat, water } 其中

HDU - 1251 統計難題 【字典樹Trie】

init nan fail printf pos 小寫 out esp spa Ignatius最近遇到一個難題,老師交給他很多單詞(只有小寫字母組成,不會有重復的單詞出現),現在老師要他統計出以某個字符串為前綴的單詞數量(單詞本身也是自己的前綴). Input輸入數據

【04】蒙特卡洛樹入門學習筆記

alter ike cnblogs append 最大的 有趣的 控制理論 空間 nod 蒙特卡洛樹學習筆記 1. 強化學習（RL） 概念 ? 強化學習是機器學習中的一個領域，強調如何基於環境而行動，以取得最大化的預期利益。其靈感來源於心理學中的行為主義理論，即有機體如何

字典樹Trie樹

bool cnblogs 博客 記錄 com strlen www dto fin 摘自大佬博客 https://www.cnblogs.com/TheRoadToTheGold/p/6290732.html 給出n個單詞和m個詢問1.查詢某個前綴是否出現過2.查

「主席樹」學習筆記

== 傳說 比較 返回值 普通 哪裏 表數 成功 可能 主席樹 主席樹——可持久化線段樹。話說這個名字的來歷也非常有意思，傳說是一位非常非常巨的巨佬發明的，他的名字叫做黃嘉泰。由於名字縮寫和一位竹席的縮寫一模一樣，於是就叫主席樹了…… 所謂可持久化線段樹，就是可以查詢歷史更

字典樹(Trie)

用Trie(也叫字首樹)來儲存字串集合。 每個單詞的結束位置對應一個“單詞結點”。反過來，從根節點到每個單詞結點的路徑上所有字母連線而成的字串就是該結點對應的字串，在程式上，將根節點編號成0，然後把其餘結點編號為從1開始的正整數，然後用一個數組來儲存每個結點的所有子節點，用下標直接存取。 具

Immediate Decodability UVA - 644 (字典樹trie)

傳送門 題意：給出一組由0或1組成的字串，組與組之間用9分隔開，然後判斷如果這個組之間有字首，那麼輸出not，否則輸出is 題解：使用字典樹，建樹直接就可以判斷，分為兩種情況，第一種情況就是字首在前面出現，直接判斷val[u]是否存在，第二種情況是字首在後面出現，那麼就在建樹的過程中看是否出

Remember the Word UVALive - 3942(字典樹trie)

傳送門 題意：這個題是先給出一個長的字串，然後相應給出若干個單詞，問這個字串能由後面給出的若干個單詞構成的方案數，比如給出abcd，給出的若干個單詞是a，b，ab，cd，這樣就有兩種構成方法了 題解：最最重要的是得要想出遞推得出答案，用d[i]表示從給出的字串中的第i位開始的字尾所能構成的方

決策樹 ID3學習筆記

最近開始看機器學習方面的知識，決策樹（DT）主要有三種演算法 ID3(Iterative Dichotomiser 3)、 C4.5、CART哈。 包括的知識有，資訊熵、資訊增益、資訊增益率、基尼指數概念，另外還有預剪枝、後剪枝等。 決策樹演算法的優點： 1：易於理解，使用白盒

字典樹 trie

具體原理：劉汝佳《演算法競賽入門經典訓練指南》P208 作用：字典樹又叫單詞查詢樹(Trie)或字首樹，是一個實現字串。你可以在O(m)(m為所給單詞的長度)時間內判斷出該單詞是否屬於字典。 程式碼模板：   struct Trie { int ch[maxnode

[線段樹合併][學習筆記]

前置知識 權值線段樹&動態開點線段樹 適用範圍 有時候我們需要對權值線段樹進行合併操作。然後就用到了線段樹合併。一般是有很多棵線段樹，然後需要將其中的兩棵合併起來。 方法 其實方法很簡單呢。就是分三種情況討論一下。假設現在要將線段樹a和線段樹b合併。並且a成為合併之後的線段樹。 如果a有當

機器學習--決策樹演算法學習筆記

一、演算法表述 決策樹學習的目的是為了產生一顆泛化能力強的數。 一般來說，一顆決策樹包含一個根節點，若干個內部節點和若干個葉節點。 葉節點對應決策結果，其他每個節點對應一個屬性測試。 每個節點包含的樣本集合根據屬性測試的結果被劃分到子節點中，根節點包含樣本全集。 從

java字典樹(Trie)實現中文模糊匹配

原理解釋： java實現：https://blog.csdn.net/yuhk231/article/details/51539840 c實現：https://blog.csdn.net/qq_31175231/article/details/77827324 程式碼模板：缺點，只能檢索

機器學習十大經典演算法之決策樹（學習筆記整理）

一、決策樹概述 決策樹是一種樹形結構，其中每個內部節點表示一個屬性上的測試，每個分支代表一個測試輸出，每個葉節點代表一種類別。決策樹是一個預測模型，代表的是物件屬性與物件值之間的一種對映關係。 最初的節點稱為根節點（如圖中的"顏色"），有分支的節點稱為中間節點

Uva1401 Remember the Word 字典樹trie

題意翻譯 Uva1401 Remember the Word (記單詞) 翻譯 題目描述 Neal 對有關組合的問題很感興趣，現在他有一個關於單詞的有趣問題要解決： 他知道大佬Ray的記憶力像儲存器一樣好，這樣的問題肯定難不倒他，於是Neal把問題給了蒟蒻

洛谷4455 [CQOI2018]社交網路 (有向圖矩陣樹定理)(學習筆記）

sro_ptx_orz qwq算是一個套路的記錄 對於一個有向圖來說 如果你要求一個外向生成樹的話，那麼如果存在一個 u →

01字典樹的學習

01字典樹的應用範圍 問題： 給定一個數值集合，然後給出一個數K，問集合中哪個數與K的異或和最大。 解題： 將數值集合中的數都變成一個個二進位制串。然後將這些“字串”插入字典樹中。 查詢時，從根節點遍歷到葉子結點，每次儘量走與K值當前數位不同的結點。

二叉查詢樹（二叉排序樹）學習筆記

本文轉載自：http://blog.csdn.net/qq_37887537/article/details/75647670在學習資料結構的時候，除了基本的之外的，還有許多樹像是二叉搜尋樹，2-3樹，紅黑樹等等。也曾經學習過二叉樹，以及前序排列中序排列後序排列等等，但是一直

字典樹(trie樹)

1. 字串檢索，詞頻統計，搜尋引擎的熱門查詢         事先將已知的一些字串（字典）的有關資訊儲存到trie樹裡，查詢另外一些未知字串是否出現過或者出現頻率。         舉例：        1）有一個1G大小的一個檔案，裡面每一行是一個詞，詞的大小不超過16位元組，記憶體限制大小是1M。