以太坊trie樹

1. 這是什麼樹！

樹，[1]木本植物之總名，主要由根、干、枝、葉、花、果組成。隨著計算機的發展，在數據結構中樹被引申為由一個集合以及在該集合上定義的一種關系構成的，由根結點和若干顆子樹構成的。

樹是具有木質樹干及樹枝的植物，多年生。一般將喬木稱為樹，主幹植株一，分枝距離地面較高，可以形成樹冠。樹有很多種。

俗語中也有將比較大的灌木稱為「樹」的，如石榴樹 （分落葉灌木或小喬木）、茶樹 （分灌木或小喬木）等。中國的國樹：銀杏。

植物里樹木區別於草。


在圖論中，樹（英語：Tree）是一種無向圖（undirected graph），其中任意兩個頂點間存在唯一一條路徑。或者說，只要沒有迴路的連通圖就是樹。森林是指互相不交並樹的集合。樹圖廣泛應用於計算機科學的數據結構中，比如二叉查找樹，堆，Trie樹以及數據壓縮中的霍夫曼樹等等。

2. TRIE 理論 是什麼

Trie又稱字典樹，是重要的數據結構，也是AC自動機的基礎，因此在這里簡單的說下什麼是字典數，並且列舉Trie上的操作。Trie的形式如下圖所示：

對於每一個節點，從根遍歷到他的過程就是一個單詞，如果這個節點被標記為紅色，就表示這個單詞存在，否則不存在。

那麼，對於一個單詞，我只要順著他從跟走到對應的節點，再看這個節點是否被標記為紅色就可以知道它是否出現過了。把這個節點標記為紅色，就相當於插入了這個單詞。

這樣一來我們詢問和插入可以一起完成，所用時間僅僅為單詞長度，在這一個樣例，便是10。

我們可以看到，trie樹每一層的節點數是26^i級別的。所以為了節省空間。我們用動態鏈表，或者用數組來模擬動態。空間的花費，不會超過單詞數×單詞長度。

基本性質可以歸納為：

1.根節點不包含字元，除根節點外每一個節點都只包含一個字元。

2.從根節點到某一節點，路徑上經過的字元連接起來，為該節點對應的字元串。

3.每個節點的所有子節點包含的字元都不相同。

我們可以動態存儲和靜態數組模擬，對於這兩種情況我們分別用POJ2001和POJ3630進行解釋！

3. 字典樹trie的時間復雜度是多少

又稱單詞查找樹，Trie樹，是一種樹形結構，是一種哈希樹的變種。典型應用是用於統計，排序和保存大量的字元串（但不僅限於字元串），所以經常被搜索引擎系統用於文本詞頻統計。

4. AVL樹，紅黑樹，B樹，B+樹，Trie樹都分別應用在哪些現實場景中

在C++ STL中，很多部分(目前包括set, multiset, map, multimap)應用了紅黑樹的變體(SGI STL中的紅黑樹有一些變化，這些修改提供了更好的性能，以及對set操作的支持)。紅黑樹是每個節點都帶有顏色屬性的二叉查找樹，顏色或紅色或黑色。在二叉查找樹強制一般要求以外，對於任何有效的紅黑樹我們增加了如下的額外要求: 性質1. 節點是紅色或黑色。 性質2. 根是黑色。 性質3 每個葉節點是黑色的。 性質4 每個紅色節點的兩個子節點都是黑色。(從每個葉子到根的所有路徑上不能有兩個連續的紅色節點) 性質5. 從任一節點到其每個葉子的所有路徑都包含相同數目的黑色節點。 An example of a red-black tree 這些約束強制了紅黑樹的關鍵性質: 從根到葉子的最長的可能路徑不多於最短的可能路徑的兩倍長。結果是這個樹大致上是平衡的。因為操作比如插入、刪除和查找某個值的最壞情況時間都要求與樹的高度成比例，這個在高度上的理論上限允許紅黑樹在最壞情況下都是高效的，而不同於普通的二叉查找樹。 要知道為什麼這些特性確保了這個結果，注意到屬性5導致了路徑不能有兩個毗連的紅色節點就足夠了。最短的可能路徑都是黑色節點，最長的可能路徑有交替的紅色和黑色節點。因為根據屬性4所有最長的路徑都有相同數目的黑色節點，這就表明了沒有路徑能多於任何其他路徑的兩倍長。 在很多樹數據結構的表示中，一個節點有可能只有一個子節點，而葉子節點包含數據。用這種範例表示紅黑樹是可能的，但是這會改變一些屬性並使演算法復雜。為此，本文中我們使用 "nil 葉子" 或"空(null)葉子"，如上圖所示，它不包含數據而只充當樹在此結束的指示。這些節點在繪圖中經常被省略，導致了這些樹好象同上述原則相矛盾，而實際上不是這樣。與此有關的結論是所有節點都有兩個子節點，盡管其中的一個或兩個可能是空葉子。

5. c++ trie樹與指針

性質：
1.根節點不包含字元，除根節點外的每一個節點都只包含一個字元。
2.從根節點到某一節點，路徑上經過的字元連接起來，為該節點對應的字元串。
3.每個節點的所有子節點包含的字元都不相同。
優點：
1.查詢快。對於長度為m的鍵值，最壞情況下只需花費O(m)的時間；而BST需要O(m log n)的時間。
2.當存儲大量字元串時，Trie耗費的空間較少。因為鍵值並非顯式存儲的，而是與其他鍵值共享子串。
操作：
1.初始化或清空：遍歷Trie，刪除所有節點，只保留根節點。

6. 編程新手想了解一下字典樹的空間復雜度分析問題, 有人可以解答一下嗎~

大神，你真好意思自稱新手

7. ···Trie樹相對於C++的map有什麼優勢

快唄，復雜度的優勢

8. 什麼是雙數組Trie樹

用vector取代C-style的數組
提起數組，大家想必都很熟悉，你可以用索引和指針來操作數組，給程序設計帶來了很大的靈活性。但是你知道它有許多天生的缺陷嗎？
首先，數組的越界可能會引起程序的崩潰(如果崩潰了，還算你走運^_^)。其次是動態性不好，包括動態改變大小，動態申請。諸如此類的事，一定會讓你傷透腦筋。有什麼辦法可以解決這些問題嗎？
你不用擔心，下面我來給大家介紹一種方法:用vector取代C-style的數組。
關於vector我不想多說，我假設大家都了解temlplate 和 STL。各位在任何一本C++的書上都可以找的到這些內容的(如果沒有，那趕快把它扔掉)。那為什麼是vector呢？我們知道vector提供了operator[]函數，可以像數組一樣的操作，而且還有邊界檢查，動態改變大小。(從這點上deque也是可以的)。vector本來就是可以用來代替一維數組的，這里只介紹用它來代替二維的數組。二維以上的可以依此類推。
我們知道，C++的template參數是可以嵌套定義的，你可以這樣定義一個模板的Instance
vector <vector <int> > array2(3);//注意> 和> 之間的空格。
這就是我們的關鍵，array2可以保存3個向量，向量的長度是可以改變的。array2[i]返回的是第i個向量。同理，array2[i][j]返回的是第i個向量中的第j個元素。
到這里，你可能會得意的說: "我明白了，很簡單嗎！ "。別急，還有一些細節問題：如下
vector <vector <int> > array2(3);
array2[1][2]=9;
我保證你的程序會segement failed,原因就是你沒有指定向量的大小。用push_back函數可以解決問題：array2[1].push_back(9);但是好象不太爽。就不能用operator[]嗎？答案是肯定的。不過要多加幾個步驟，如下：
for(int i=0;i <3;i++)
array2[i].resize(3);
這樣，你就定義了一個3X3的數組了（另一個3在 申明時定義的）。而且你可以隨時改變它的大小。
其他的，你還可以用C++的異常機制來捕獲如下標越界等非法行為。進行必要的處理。使你的程序更加的健壯。具體的方法我就不深入介紹了。留給各位自己鑽研。下面提供一個範例，供參考。
//用vector來代替數組
// 潘李亮2002-1-13
//在GNU c++ Mandrake Linux7.0下通過,
//在VC下會有變數定義問題，大家自己解決
#include <iostream>
#include <vector>
using namespace std;
void main()
{
vector < vector <int> > array(3);
for(int i=0;i <3;i++)
array[i].resize(3);//設置數組的大小3X3
//現在你可以和使用數組一樣使用這個vector
for(int i=0;i <3;i++)
for(int j=0;j <3;j++)
array[i][j]=(i*j);
//輸出
for(int i=0;i <3;i++)
{
for(int j=0;j <3;j++)
cout < <array[i][j] < < " ";
cout < <endl;
}
array.resize(5);
arry[3].resize(3);
arry[4].resize(3);
//現在是5X3的數組了
for(int i=0;i <5;i++)
for(int j=0;j <3;j++)
array[i][j]=(i*j);
for(int i=0;i <5;i++)
{
for(int j=0;j <3;j++)
cout < <array[i][j] < < " ";
cout < <endl;
}
}

9. Trie單詞查找樹 pascal 實現

Trie樹就是字元樹，其核心思想就是空間換時間。我以前用過的資料 網上關於這個字典樹的資料挺少的
給你100000個長度不超過10的單詞。對於每一個單詞，我們要判斷他出沒出現過，如果出現了，第一次出現第幾個位置。
這題當然可以用hash來，但是我要介紹的是trie樹。在某些方面它的用途更大。比如說對於某一個單詞，我要詢問它的前綴是否出現過。這樣hash就不好搞了，而用trie還是很簡單。
現在回到例子中，如果我們用最傻的方法，對於每一個單詞，我們都要去查找它前面的單詞中是否有它。那麼這個演算法的復雜度就是O(n^2)。顯然對於100000的范圍難以接受。現在我們換個思路想。假設我要查詢的單詞是abcd，那麼在他前面的單詞中，以b，c，d，f之類開頭的我顯然不必考慮。而只要找以a開頭的中是否存在abcd就可以了。同樣的，在以a開頭中的單詞中，我們只要考慮以b作為第二個字母的……這樣一個樹的模型就漸漸清晰了……
假設有b，abc，abd，bcd，abcd，efg，hii這6個單詞，我們構建的樹就是這樣的。

對於每一個節點，從根遍歷到他的過程就是一個單詞，如果這個節點被標記為紅色，就表示這個單詞存在，否則不存在。
那麼，對於一個單詞，我只要順著他從跟走到對應的節點，再看這個節點是否被標記為紅色就可以知道它是否出現過了。把這個節點標記為紅色，就相當於插入了這個單詞。
這樣一來我們詢問和插入可以一起完成，所用時間僅僅為單詞長度，在這一個樣例，便是10。
我們可以看到，trie樹每一層的節點數是26^i級別的。所以為了節省空間。我們用動態鏈表，或者用數組來模擬動態。空間的花費，不會超過單詞數×單詞長度。
程序非常好實現，區區幾行，我就不寫了，自己琢磨吧。
如果還是不懂請留言。

下面提供一個查找單詞是否在給定的字典中的標程：
program trie;
type
rec=record
Got:boolean;
next:array['a'..'z'] of Longint;
end;
var
n,i,j,Now,Tn:Longint;
s:string;
T:array[1..1000] of rec;
flag:boolean;
begin
Readln(n);
Tn:=1;
T[1].Got:=False;
fillchar(T[1].next,sizeof(T[1].next),0);
for i:=1 to n do
begin
readln(s);
Now:=1;
for j:=1 to length(s) do
if T[now].Next[s[j]]<>0 then now:=t[now].next[s[j]] else
begin
Inc(Tn);
T[tn].Got:=false;
fillchar(T[tn].next,sizeof(T[tn].next),0);
T[Now].next[s[j]]:=Tn;
Now:=Tn;
end;
T[now].Got:=true;
end;
readln(s);
while s<>'exit' do
begin
Now:=1;flag:=true;
for j:=1 to length(s) do
if T[now].Next[s[j]]<>0 then now:=t[now].next[s[j]] else
begin
flag:=false;
break;
end;
if flag then
if T[now].Got=false then flag:=false;
if flag then writeln('the word is in the tree') else
writeln('can''t find it!');
Readln(s);
end;
end.

一個單詞前綴樹的題，但是我卻用trie樹+bm演算法簡化版做的

密碼破譯
【問題描述】
由於最近功課過於繁忙，Tim竟然忘記了自己電腦的密碼，幸運的是Tim在設計電腦密碼的時候，用了一個非常特殊的方法記錄下了密碼。這個方法是：Tim把密碼和其它的一些假密碼共同記錄在了一個本子上面。為了能夠從這些字元串中找出正確的密碼，Tim又在另外一個本子上面寫了一個很長的字元串，而正確的密碼就是在這個字元串中出現次數最多的一個密碼。例如串ababa，假若密碼是abab和aba，那麼正確的密碼是aba，因為aba在這個字元串中出現了2次。
現在你得到了Tim的這兩個本子，希望你能夠編寫一個程序幫助Tim找出正確的密碼。
【輸入】
輸入由兩個部分組成。其中第一部分由若干行組成，每一行記錄了一個密碼，密碼的均長度小於等於255位，並且都由小寫字母組成。然後一個空行，第二部分記錄了一個很長的字元串，並且以』.』結束，其中只包含了小寫字母。

【輸出】
輸出文件名為Pass.out。輸出文件由僅有一行，為一個整數，表示正確密碼在字元串中出現的次數。如果這個出現次數為0，輸出「No find」。

【樣例】：
Pass.in Pass.out
ab 6
abc
bdc
abcd

.

program pass;
const
filein='pass.in';
fileout='pass.out';
type
rec=record
which:Longint;
Next:array['a'..'z'] of Longint;
end;
var
o,now,i,Tn,Dn,temp,Ans:Longint;
s:string;
c:char;
T:array[1..1000000] of REc;
data:array[1..5000] of string;
dLong:array[1..5000] of longint;
use:array[1..5000] of boolean;
d:array[1..3000000] of char;
Appear:array['a'..'z'] of Longint;
Long:Longint;
f:boolean;
function Compare(x:Longint):Longint;
var
s,i,Now,L,temp:Longint;
begin
s:=0;
fillchar(appear,sizeof(appear),0);
L:=length(data[x]);
for i:=1 to L do
Appear[data[x][i]]:=i;
Now:=L;
while NOw<=Long do
begin
if D[now]<>data[x][L] then Inc(now,L-Appear[D[now]]) else
begin
temp:=L-1;
while (temp>0) and (Data[x][temp]=d[Now-(L-temp)]) do dec(temp);
if temp=0 then Inc(s);
Inc(Now);
end;
end;
Compare:=S;
end;
procere sort(l,r:Longint);
var
i,j,x:Longint;
sy:string;
ly:Longint;
begin
i:=l;j:=r;x:=dLong[(l+r) div 2];
repeat
while dLong[i]<x do inc(i);
while dlong[j]>x do dec(j);
if i<=j then
begin
sy:=data[i];
data[i]:=data[j];
data[j]:=sy;
ly:=dlong[i];
dlong[i]:=dlong[j];
dlong[j]:=ly;
inc(i);
dec(j);
end;
until i>j;
if i<r then sort(i,r);
if j>l then sort(l,j);
end;
begin
fillchar(use,sizeof(use),true);
fillchar(t,sizeof(t),0);
Assign(input,filein);
Assign(output,fileout);
rewrite(output);
reset(input);
tn:=1;
readln(s);
Dn:=0;
while s<>'' do
begin
Inc(dn);
data[dn]:=s;
dLong[dn]:=length(s);
readln(s);
end;
sort(1,Dn);
for o:=1 to Dn do
begin
s:=data[o];
NOw:=1;
f:=true;
for i:=1 to Length(s) do
if t[now].Next[s[i]]<>0 then
begin
Now:=t[now].next[s[i]];
if t[now].which<>0 then
begin
f:=false;
break
end;
end else
begin
Inc(tn);
t[now].next[s[i]]:=tn;
now:=tn;
end;
if f then t[now].which:=o;
if not f then use[o]:=false;
end;
Long:=0;
repeat
read(c);
if c<>'.' then
begin
Inc(Long);
d[Long]:=c;
end;
until c='.';
for i:=1 to Dn do
begin
if use[i] then
begin
temp:=Compare(i);
if temp>ans then ans:=temp;
end;
end;
if ans=0 then writeln('No find') else
writeln(Ans);
close(input);
close(output);
end.

10. Python裡面用什麼trie樹實現模塊比較好

三種方法：
正則表達式，python中re模塊，python自帶；

pyquery，需另外安裝；
beautifulsoup，需另外安裝。
具體使用上，對於比較復雜的獲取，後兩者操作更方便，前者效率更高。