[轉]數據結構中各種樹
閱讀目錄
- 1. 二叉樹
- 2. 二叉查找樹
- 3. 平衡二叉樹
- 3.1 平衡查找樹之AVL樹
- 3.2 平衡二叉樹之紅黑樹
- 4. B樹
- 5. B+樹
- 6. B*樹
- 7. Trie樹
數據結構中有很多樹的結構，其中包括二叉樹、二叉搜索樹、2-3樹、紅黑樹等等。本文中對數據結構中常見的幾種樹的概念和用途進行了匯總，不求嚴格精準，但求簡單易懂。
1. 二叉樹
二叉樹是數據結構中一種重要的數據結構，也是樹表家族最為基礎的結構。
二叉樹的定義：二叉樹的每個結點至多只有二棵子樹(不存在度大於2的結點)，二叉樹的子樹有左右之分，次序不能顛倒。二叉樹的第i層至多有2i-1個結點；深度為k的二叉樹至多有2k-1
二叉樹的示例：
滿二叉樹和完全二叉樹：
滿二叉樹：除最後一層無任何子節點外，每一層上的所有結點都有兩個子結點。也可以這樣理解，除葉子結點外的所有結點均有兩個子結點。節點數達到最大值，所有葉子結點必須在同一層上。
滿二叉樹的性質：
1) 一顆樹深度為h，最大層數為k，深度與最大層數相同，k=h;
2) 葉子數為2h;
3) 第k層的結點數是：2k-1;
4) 總結點數是：2k-1，且總節點數一定是奇數。
完全二叉樹：若設二叉樹的深度為h，除第 h 層外，其它各層 (1～(h-1)層) 的結點數都達到最大個數，第h層所有的結點都連續集中在最左邊，這就是完全二叉樹。
註：完全二叉樹是效率很高的數據結構，堆是一種完全二叉樹或者近似完全二叉樹，所以效率極高，像十分常用的排序算法、Dijkstra算法、Prim算法等都要用堆才能優化，二叉排序樹的效率也要借助平衡性來提高，而平衡性基於完全二叉樹。
二叉樹的性質：
1) 在非空二叉樹中，第i層的結點總數不超過2i-1, i>=1;
2) 深度為h的二叉樹最多有2h-1個結點(h>=1)，最少有h個結點;
3) 對於任意一棵二叉樹，如果其葉結點數為N0，而度數為2的結點總數為N2，則N0=N2+1; 4) 具有n個結點的完全二叉樹的深度為log2(n+1); 5)有N個結點的完全二叉樹各結點如果用順序方式存儲，則結點之間有如下關系： 若I為結點編號則 如果I>1，則其父結點的編號為I/2； 如果2I<=N，則其左兒子（即左子樹的根結點）的編號為2I；若2I>N，則無左兒子； 如果2I+1<=N，則其右兒子的結點編號為2I+1；若2I+1>N，則無右兒子。 6)給定N個節點，能構成h(N)種不同的二叉樹，其中h(N)為卡特蘭數的第N項，h(n)=C(2*n, n)/(n+1)。 7)設有i個枝點，I為所有枝點的道路長度總和，J為葉的道路長度總和J=I+2i2. 二叉查找樹
二叉查找樹定義：又稱為是二叉排序樹（Binary Sort Tree）或二叉搜索樹。二叉排序樹或者是一棵空樹，或者是具有下列性質的二叉樹： 1) 若左子樹不空，則左子樹上所有結點的值均小於它的根結點的值； 2) 若右子樹不空，則右子樹上所有結點的值均大於或等於它的根結點的值； 3) 左、右子樹也分別為二叉排序樹； 4) 沒有鍵值相等的節點。 二叉查找樹的性質：對二叉查找樹進行中序遍歷，即可得到有序的數列。 二叉查找樹的時間復雜度：它和二分查找一樣，插入和查找的時間復雜度均為O(logn)，但是在最壞的情況下仍然會有O(n)的時間復雜度。原因在於插入和刪除元素的時候，樹沒有保持平衡（比如，我們查找上圖（b）中的“93”，我們需要進行n次查找操作）。我們追求的是在最壞的情況下仍然有較好的時間復雜度，這就是平衡查找樹設計的初衷。 二叉查找樹的高度決定了二叉查找樹的查找效率。二叉查找樹的插入過程如下：
1) 若當前的二叉查找樹為空，則插入的元素為根節點;
2) 若插入的元素值小於根節點值，則將元素插入到左子樹中;
3) 若插入的元素值不小於根節點值，則將元素插入到右子樹中。
二叉查找樹的刪除，分三種情況進行處理：
1) p為葉子節點，直接刪除該節點，再修改其父節點的指針（註意分是根節點和不是根節點），如圖a;
2) p為單支節點（即只有左子樹或右子樹）。讓p的子樹與p的父親節點相連，刪除p即可（註意分是根節點和不是根節點），如圖b;
3) p的左子樹和右子樹均不空。找到p的後繼y，因為y一定沒有左子樹，所以可以刪除y，並讓y的父親節點成為y的右子樹的父親節點，並用y的值代替p的值；或者方法二是找到p的前驅x，x一定沒有右子樹，所以可以刪除x，並讓x的父親節點成為y的左子樹的父親節點。如圖c。
二叉樹相關實現源碼：
插入操作：
struct node
{
int val;
pnode lchild;
pnode rchild;
};
pnode BT = NULL;
//遞歸方法插入節點
pnode insert(pnode root, int x)
{
pnode p = (pnode)malloc(LEN);
p->val = x;
p->lchild = NULL;
p->rchild = NULL;
if(root == NULL){
root = p;
}
else if(x < root->val){
root->lchild = insert(root->lchild, x);
}
else{
root->rchild = insert(root->rchild, x);
}
return root;
}
//非遞歸方法插入節點
void insert_BST(pnode q, int x)
{
pnode p = (pnode)malloc(LEN);
p->val = x;
p->lchild = NULL;
p->rchild = NULL;
if(q == NULL){
BT = p;
return ;
}
while(q->lchild != p && q->rchild != p){
if(x < q->val){
if(q->lchild){
q = q->lchild;
}
else{
q->lchild = p;
}
}
else{
if(q->rchild){
q = q->rchild;
}
else{
q->rchild = p;
}
}
}
return;
}
刪除操作：
bool delete_BST(pnode p, int x) //返回一個標誌，表示是否找到被刪元素
{
bool find = false;
pnode q;
p = BT;
while(p && !find){ //尋找被刪元素
if(x == p->val){ //找到被刪元素
find = true;
}
else if(x < p->val){ //沿左子樹找
q = p;
p = p->lchild;
}
else{ //沿右子樹找
q = p;
p = p->rchild;
}
}
if(p == NULL){ //沒找到
cout << "沒有找到" << x << endl;
}
if(p->lchild == NULL && p->rchild == NULL){ //p為葉子節點
if(p == BT){ //p為根節點
BT = NULL;
}
else if(q->lchild == p){
q->lchild = NULL;
}
else{
q->rchild = NULL;
}
free(p); //釋放節點p
}
else if(p->lchild == NULL || p->rchild == NULL){ //p為單支子樹
if(p == BT){ //p為根節點
if(p->lchild == NULL){
BT = p->rchild;
}
else{
BT = p->lchild;
}
}
else{
if(q->lchild == p && p->lchild){ //p是q的左子樹且p有左子樹
q->lchild = p->lchild; //將p的左子樹鏈接到q的左指針上
}
else if(q->lchild == p && p->rchild){
q->lchild = p->rchild;
}
else if(q->rchild == p && p->lchild){
q->rchild = p->lchild;
}
else{
q->rchild = p->rchild;
}
}
free(p);
}
else{ //p的左右子樹均不為空
pnode t = p;
pnode s = p->lchild; //從p的左子節點開始
while(s->rchild){ //找到p的前驅，即p左子樹中值最大的節點
t = s;
s = s->rchild;
}
p->val = s->val; //把節點s的值賦給p
if(t == p){
p->lchild = s->lchild;
}
else{
t->rchild = s->lchild;
}
free(s);
}
return find;
}
查找操作：
pnode search_BST(pnode p, int x)
{
bool solve = false;
while(p && !solve){
if(x == p->val){
solve = true;
}
else if(x < p->val){
p = p->lchild;
}
else{
p = p->rchild;
}
}
if(p == NULL){
cout << "沒有找到" << x << endl;
}
return p;
}
回到頂部
3. 平衡二叉樹
我們知道，對於一般的二叉搜索樹（Binary Search Tree），其期望高度（即為一棵平衡樹時）為log2n，其各操作的時間復雜度O(log2n)同時也由此而決定。但是，在某些極端的情況下（如在插入的序列是有序的時），二叉搜索樹將退化成近似鏈或鏈，此時，其操作的時間復雜度將退化成線性的，即O(n)。我們可以通過隨機化建立二叉搜索樹來盡量的避免這種情況，但是在進行了多次的操作之後，由於在刪除時，我們總是選擇將待刪除節點的後繼代替它本身，這樣就會造成總是右邊的節點數目減少，以至於樹向左偏沈。這同時也會造成樹的平衡性受到破壞，提高它的操作的時間復雜度。於是就有了我們下邊介紹的平衡二叉樹。
平衡二叉樹定義：平衡二叉樹（Balanced Binary Tree）又被稱為AVL樹（有別於AVL算法），且具有以下性質：它是一 棵空樹或它的左右兩個子樹的高度差的絕對值不超過1，並且左右兩個子樹都是一棵平衡二叉樹。平衡二叉樹的常用算法有紅黑樹、AVL樹等。在平衡二叉搜索樹中，我們可以看到，其高度一般都良好地維持在O(log2n)，大大降低了操作的時間復雜度。
最小二叉平衡樹的節點的公式如下：
F(n)=F(n-1)+F(n-2)+1
這個類似於一個遞歸的數列，可以參考Fibonacci數列，1是根節點，F(n-1)是左子樹的節點數量，F(n-2)是右子樹的節點數量。
回到頂部3.1 平衡查找樹之AVL樹
有關AVL樹的具體實現，可以參考C小加的博客《一步一步寫平衡二叉樹（AVL）》。
AVL樹定義：AVL樹是最先發明的自平衡二叉查找樹。AVL樹得名於它的發明者 G.M. Adelson-Velsky 和 E.M. Landis，他們在 1962 年的論文 "An algorithm for the organization of information" 中發表了它。在AVL中任何節點的兩個兒子子樹的高度最大差別為1，所以它也被稱為高度平衡樹，n個結點的AVL樹最大深度約1.44log2n。查找、插入和刪除在平均和最壞情況下都是O(logn)。增加和刪除可能需要通過一次或多次樹旋轉來重新平衡這個樹。這個方案很好的解決了二叉查找樹退化成鏈表的問題，把插入，查找，刪除的時間復雜度最好情況和最壞情況都維持在O(logN)。但是頻繁旋轉會使插入和刪除犧牲掉O(logN)左右的時間，不過相對二叉查找樹來說，時間上穩定了很多。
AVL樹的自平衡操作——旋轉：
AVL樹最關鍵的也是最難的一步操作就是旋轉。旋轉主要是為了實現AVL樹在實施了插入和刪除操作以後，樹重新回到平衡的方法。下面我們重點研究一下AVL樹的旋轉。
對於一個平衡的節點，由於任意節點最多有兩個兒子，因此高度不平衡時，此節點的兩顆子樹的高度差2.容易看出，這種不平衡出現在下面四種情況：
1) 6節點的左子樹3節點高度比右子樹7節點大2，左子樹3節點的左子樹1節點高度大於右子樹4節點，這種情況成為左左。
2) 6節點的左子樹2節點高度比右子樹7節點大2，左子樹2節點的左子樹1節點高度小於右子樹4節點，這種情況成為左右。
3) 2節點的左子樹1節點高度比右子樹5節點小2，右子樹5節點的左子樹3節點高度大於右子樹6節點，這種情況成為右左。
4) 2節點的左子樹1節點高度比右子樹4節點小2，右子樹4節點的左子樹3節點高度小於右子樹6節點，這種情況成為右右。
從圖2中可以可以看出，1和4兩種情況是對稱的，這兩種情況的旋轉算法是一致的，只需要經過一次旋轉就可以達到目標，我們稱之為單旋轉。2和3兩種情況也是對稱的，這兩種情況的旋轉算法也是一致的，需要進行兩次旋轉，我們稱之為雙旋轉。
單旋轉
單旋轉是針對於左左和右右這兩種情況的解決方案，這兩種情況是對稱的，只要解決了左左這種情況，右右就很好辦了。圖3是左左情況的解決方案，節點k2不滿足平衡特性，因為它的左子樹k1比右子樹Z深2層，而且k1子樹中，更深的一層的是k1的左子樹X子樹，所以屬於左左情況。
為使樹恢復平衡，我們把k2變成這棵樹的根節點，因為k2大於k1，把k2置於k1的右子樹上，而原本在k1右子樹的Y大於k1，小於k2，就把Y置於k2的左子樹上，這樣既滿足了二叉查找樹的性質，又滿足了平衡二叉樹的性質。
這樣的操作只需要一部分指針改變，結果我們得到另外一顆二叉查找樹，它是一棵AVL樹，因為X向上一移動了一層，Y還停留在原來的層面上，Z向下移動了一層。整棵樹的新高度和之前沒有在左子樹上插入的高度相同，插入操作使得X高度長高了。因此，由於這顆子樹高度沒有變化，所以通往根節點的路徑就不需要繼續旋轉了。
雙旋轉
對於左右和右左這兩種情況，單旋轉不能使它達到一個平衡狀態，要經過兩次旋轉。雙旋轉是針對於這兩種情況的解決方案，同樣的，這樣兩種情況也是對稱的，只要解決了左右這種情況，右左就很好辦了。圖4是左右情況的解決方案，節點k3不滿足平衡特性，因為它的左子樹k1比右子樹Z深2層，而且k1子樹中，更深的一層的是k1的右子樹k2子樹，所以屬於左右情況。
為使樹恢復平衡，我們需要進行兩步，第一步，把k1作為根，進行一次右右旋轉，旋轉之後就變成了左左情況，所以第二步再進行一次左左旋轉，最後得到了一棵以k2為根的平衡二叉樹。
AVL樹實現源碼：
//AVL樹節點信息
template<class T>
class TreeNode
{
public:
TreeNode():lson(NULL),rson(NULL),freq(1),hgt(0){}
T data;//值
int hgt;//高度
unsigned int freq;//頻率
TreeNode* lson;//指向左兒子的地址
TreeNode* rson;//指向右兒子的地址
};
//AVL樹類的屬性和方法聲明
template<class T>
class AVLTree
{
private:
TreeNode<T>* root;//根節點
void insertpri(TreeNode<T>* &node,T x);//插入
TreeNode<T>* findpri(TreeNode<T>* node,T x);//查找
void insubtree(TreeNode<T>* node);//中序遍歷
void Deletepri(TreeNode<T>* &node,T x);//刪除
int height(TreeNode<T>* node);//求樹的高度
void SingRotateLeft(TreeNode<T>* &k2);//左左情況下的旋轉
void SingRotateRight(TreeNode<T>* &k2);//右右情況下的旋轉
void DoubleRotateLR(TreeNode<T>* &k3);//左右情況下的旋轉
void DoubleRotateRL(TreeNode<T>* &k3);//右左情況下的旋轉
int Max(int cmpa,int cmpb);//求最大值
public:
AVLTree():root(NULL){}
void insert(T x);//插入接口
TreeNode<T>* find(T x);//查找接口
void Delete(T x);//刪除接口
void traversal();//遍歷接口
};
//計算節點的高度
template<class T>
int AVLTree<T>::height(TreeNode<T>* node)
{
if(node!=NULL)
return node->hgt;
return -1;
}
//求最大值
template<class T>
int AVLTree<T>::Max(int cmpa,int cmpb)
{
return cmpa>cmpb?cmpa:cmpb;
}
//左左情況下的旋轉
template<class T>
void AVLTree<T>::SingRotateLeft(TreeNode<T>* &k2)
{
TreeNode<T>* k1;
k1=k2->lson;
k2->lson=k1->rson;
k1->rson=k2;
k2->hgt=Max(height(k2->lson),height(k2->rson))+1;
k1->hgt=Max(height(k1->lson),k2->hgt)+1;
}
//右右情況下的旋轉
template<class T>
void AVLTree<T>::SingRotateRight(TreeNode<T>* &k2)
{
TreeNode<T>* k1;
k1=k2->rson;
k2->rson=k1->lson;
k1->lson=k2;
k2->hgt=Max(height(k2->lson),height(k2->rson))+1;
k1->hgt=Max(height(k1->rson),k2->hgt)+1;
}
//左右情況的旋轉
template<class T>
void AVLTree<T>::DoubleRotateLR(TreeNode<T>* &k3)
{
SingRotateRight(k3->lson);
SingRotateLeft(k3);
}
//右左情況的旋轉
template<class T>
void AVLTree<T>::DoubleRotateRL(TreeNode<T>* &k3)
{
SingRotateLeft(k3->rson);
SingRotateRight(k3);
}
//插入
template<class T>
void AVLTree<T>::insertpri(TreeNode<T>* &node,T x)
{
if(node==NULL)//如果節點為空,就在此節點處加入x信息
{
node=new TreeNode<T>();
node->data=x;
return;
}
if(node->data>x)//如果x小於節點的值,就繼續在節點的左子樹中插入x
{
insertpri(node->lson,x);
if(2==height(node->lson)-height(node->rson))
if(x<node->lson->data)
SingRotateLeft(node);
else
DoubleRotateLR(node);
}
else if(node->data<x)//如果x大於節點的值,就繼續在節點的右子樹中插入x
{
insertpri(node->rson,x);
if(2==height(node->rson)-height(node->lson))//如果高度之差為2的話就失去了平衡,需要旋轉
if(x>node->rson->data)
SingRotateRight(node);
else
DoubleRotateRL(node);
}
else ++(node->freq);//如果相等,就把頻率加1
node->hgt=Max(height(node->lson),height(node->rson));
}
//插入接口
template<class T>
void AVLTree<T>::insert(T x)
{
insertpri(root,x);
}
//查找
template<class T>
TreeNode<T>* AVLTree<T>::findpri(TreeNode<T>* node,T x)
{
if(node==NULL)//如果節點為空說明沒找到,返回NULL
{
return NULL;
}
if(node->data>x)//如果x小於節點的值,就繼續在節點的左子樹中查找x
{
return findpri(node->lson,x);
}
else if(node->data<x)//如果x大於節點的值,就繼續在節點的左子樹中查找x
{
return findpri(node->rson,x);
}
else return node;//如果相等,就找到了此節點
}
//查找接口
template<class T>
TreeNode<T>* AVLTree<T>::find(T x)
{
return findpri(root,x);
}
//刪除
template<class T>
void AVLTree<T>::Deletepri(TreeNode<T>* &node,T x)
{
if(node==NULL) return ;//沒有找到值是x的節點
if(x < node->data)
{
Deletepri(node->lson,x);//如果x小於節點的值,就繼續在節點的左子樹中刪除x
if(2==height(node->rson)-height(node->lson))
if(node->rson->lson!=NULL&&(height(node->rson->lson)>height(node->rson->rson)) )
DoubleRotateRL(node);
else
SingRotateRight(node);
}
else if(x > node->data)
{
Deletepri(node->rson,x);//如果x大於節點的值,就繼續在節點的右子樹中刪除x
if(2==height(node->lson)-height(node->rson))
if(node->lson->rson!=NULL&& (height(node->lson->rson)>height(node->lson->lson) ))
DoubleRotateLR(node);
else
SingRotateLeft(node);
}
else//如果相等,此節點就是要刪除的節點
{
if(node->lson&&node->rson)//此節點有兩個兒子
{
TreeNode<T>* temp=node->rson;//temp指向節點的右兒子
while(temp->lson!=NULL) temp=temp->lson;//找到右子樹中值最小的節點
//把右子樹中最小節點的值賦值給本節點
node->data=temp->data;
node->freq=temp->freq;
Deletepri(node->rson,temp->data);//刪除右子樹中最小值的節點
if(2==height(node->lson)-height(node->rson))
{
if(node->lson->rson!=NULL&& (height(node->lson->rson)>height(node->lson->lson) ))
DoubleRotateLR(node);
else
SingRotateLeft(node);
}
}
else//此節點有1個或0個兒子
{
TreeNode<T>* temp=node;
if(node->lson==NULL)//有右兒子或者沒有兒子
node=node->rson;
else if(node->rson==NULL)//有左兒子
node=node->lson;
delete(temp);
temp=NULL;
}
}
if(node==NULL) return;
node->hgt=Max(height(node->lson),height(node->rson))+1;
return;
}
//刪除接口
template<class T>
void AVLTree<T>::Delete(T x)
{
Deletepri(root,x);
}
//中序遍歷函數
template<class T>
void AVLTree<T>::insubtree(TreeNode<T>* node)
{
if(node==NULL) return;
insubtree(node->lson);//先遍歷左子樹
cout<<node->data<<" ";//輸出根節點
insubtree(node->rson);//再遍歷右子樹
}
//中序遍歷接口
template<class T>
void AVLTree<T>::traversal()
{
insubtree(root);
}
回到頂部
3.2 平衡二叉樹之紅黑樹
紅黑樹的定義：紅黑樹是一種自平衡二叉查找樹，是在計算機科學中用到的一種數據結構，典型的用途是實現關聯數組。它是在1972年由魯道夫·貝爾發明的，稱之為"對稱二叉B樹"，它現代的名字是在 Leo J. Guibas 和 Robert Sedgewick 於1978年寫的一篇論文中獲得的。它是復雜的，但它的操作有著良好的最壞情況運行時間，並且在實踐中是高效的: 它可以在O(logn)時間內做查找，插入和刪除，這裏的n是樹中元素的數目。
紅黑樹和AVL樹一樣都對插入時間、刪除時間和查找時間提供了最好可能的最壞情況擔保。這不只是使它們在時間敏感的應用如實時應用（real time application）中有價值，而且使它們有在提供最壞情況擔保的其他數據結構中作為建造板塊的價值；例如，在計算幾何中使用的很多數據結構都可以基於紅黑樹。此外，紅黑樹還是2-3-4樹的一種等同，它們的思想是一樣的，只不過紅黑樹是2-3-4樹用二叉樹的形式表示的。
紅黑樹的性質：
紅黑樹是每個節點都帶有顏色屬性的二叉查找樹，顏色為紅色或黑色。在二叉查找樹強制的一般要求以外，對於任何有效的紅黑樹我們增加了如下的額外要求:
性質1. 節點是紅色或黑色。
性質2. 根是黑色。
性質3. 所有葉子都是黑色（葉子是NIL節點）。
性質4. 每個紅色節點必須有兩個黑色的子節點。(從每個葉子到根的所有路徑上不能有兩個連續的紅色節點。)
性質5. 從任一節點到其每個葉子的所有簡單路徑都包含相同數目的黑色節點。
下面是一個具體的紅黑樹的圖例：
這些約束確保了紅黑樹的關鍵特性: 從根到葉子的最長的可能路徑不多於最短的可能路徑的兩倍長。結果是這個樹大致上是平衡的。因為操作比如插入、刪除和查找某個值的最壞情況時間都要求與樹的高度成比例，這個在高度上的理論上限允許紅黑樹在最壞情況下都是高效的，而不同於普通的二叉查找樹。
要知道為什麽這些性質確保了這個結果，註意到性質4導致了路徑不能有兩個毗連的紅色節點就足夠了。最短的可能路徑都是黑色節點，最長的可能路徑有交替的紅色和黑色節點。因為根據性質5所有最長的路徑都有相同數目的黑色節點，這就表明了沒有路徑能多於任何其他路徑的兩倍長。
以下內容整理自wiki百科之紅黑樹。
紅黑樹的自平衡操作：
因為每一個紅黑樹也是一個特化的二叉查找樹，因此紅黑樹上的只讀操作與普通二叉查找樹上的只讀操作相同。然而，在紅黑樹上進行插入操作和刪除操作會導致不再符合紅黑樹的性質。恢復紅黑樹的性質需要少量(O(logn))的顏色變更(實際是非常快速的)和不超過三次樹旋轉(對於插入操作是兩次)。雖然插入和刪除很復雜，但操作時間仍可以保持為O(logn) 次。
我們首先以二叉查找樹的方法增加節點並標記它為紅色。如果設為黑色，就會導致根到葉子的路徑上有一條路上，多一個額外的黑節點，這個是很難調整的（違背性質5）。但是設為紅色節點後，可能會導致出現兩個連續紅色節點的沖突，那麽可以通過顏色調換（color flips）和樹旋轉來調整。下面要進行什麽操作取決於其他臨近節點的顏色。同人類的家族樹中一樣，我們將使用術語叔父節點來指一個節點的父節點的兄弟節點。註意:
- 性質1和性質3總是保持著。
- 性質4只在增加紅色節點、重繪黑色節點為紅色，或做旋轉時受到威脅。
- 性質5只在增加黑色節點、重繪紅色節點為黑色，或做旋轉時受到威脅。
插入操作：
假設，將要插入的節點標為N，N的父節點標為P，N的祖父節點標為G，N的叔父節點標為U。在圖中展示的任何顏色要麽是由它所處情形這些所作的假定，要麽是假定所暗含的。
情形1: 該樹為空樹，直接插入根結點的位置，違反性質1，把節點顏色有紅改為黑即可。
情形2: 插入節點N的父節點P為黑色，不違反任何性質，無需做任何修改。在這種情形下，樹仍是有效的。性質5也未受到威脅，盡管新節點N有兩個黑色葉子子節點；但由於新節點N是紅色，通過它的每個子節點的路徑就都有同通過它所取代的黑色的葉子的路徑同樣數目的黑色節點，所以依然滿足這個性質。
註： 情形1很簡單，情形2中P為黑色，一切安然無事，但P為紅就不一樣了，下邊是P為紅的各種情況，也是真正難懂的地方。
情形3: 如果父節點P和叔父節點U二者都是紅色，(此時新插入節點N做為P的左子節點或右子節點都屬於情形3,這裏右圖僅顯示N做為P左子的情形)則我們可以將它們兩個重繪為黑色並重繪祖父節點G為紅色(用來保持性質4)。現在我們的新節點N有了一個黑色的父節點P。因為通過父節點P或叔父節點U的任何路徑都必定通過祖父節點G，在這些路徑上的黑節點數目沒有改變。但是，紅色的祖父節點G的父節點也有可能是紅色的，這就違反了性質4。為了解決這個問題，我們在祖父節點G上遞歸地進行上述情形的整個過程（把G當成是新加入的節點進行各種情形的檢查）。比如，G為根節點，那我們就直接將G變為黑色（情形1）；如果G不是根節點，而它的父節點為黑色，那符合所有的性質，直接插入即可（情形2）；如果G不是根節點，而它的父節點為紅色，則遞歸上述過程（情形3）。
情形4: 父節點P是紅色而叔父節點U是黑色或缺少，新節點N是其父節點的左子節點，而父節點P又是其父節點G的左子節點。在這種情形下，我們進行針對祖父節點G的一次右旋轉; 在旋轉產生的樹中，以前的父節點P現在是新節點N和以前的祖父節點G的父節點。我們知道以前的祖父節點G是黑色，否則父節點P就不可能是紅色(如果P和G都是紅色就違反了性質4，所以G必須是黑色)。我們切換以前的父節點P和祖父節點G的顏色，結果的樹滿足性質4。性質5也仍然保持滿足，因為通過這三個節點中任何一個的所有路徑以前都通過祖父節點G，現在它們都通過以前的父節點P。在各自的情形下，這都是三個節點中唯一的黑色節點。
情形5: 父節點P是紅色而叔父節點U是黑色或缺少，並且新節點N是其父節點P的右子節點而父節點P又是其父節點的左子節點。在這種情形下，我們進行一次左旋轉調換新節點和其父節點的角色; 接著，我們按情形4處理以前的父節點P以解決仍然失效的性質4。註意這個改變會導致某些路徑通過它們以前不通過的新節點N（比如圖中1號葉子節點）或不通過節點P（比如圖中3號葉子節點），但由於這兩個節點都是紅色的，所以性質5仍有效。
註: 插入實際上是原地算法，因為上述所有調用都使用了尾部遞歸。
刪除操作：
如果需要刪除的節點有兩個兒子，那麽問題可以被轉化成刪除另一個只有一個兒子的節點的問題。對於二叉查找樹，在刪除帶有兩個非葉子兒子的節點的時候，我們找到要麽在它的左子樹中的最大元素、要麽在它的右子樹中的最小元素，並把它的值轉移到要刪除的節點中。我們接著刪除我們從中復制出值的那個節點，它必定有少於兩個非葉子的兒子。因為只是復制了一個值，不違反任何性質，這就把問題簡化為如何刪除最多有一個兒子的節點的問題。它不關心這個節點是最初要刪除的節點還是我們從中復制出值的那個節點。
我們只需要討論刪除只有一個兒子的節點(如果它兩個兒子都為空，即均為葉子，我們任意將其中一個看作它的兒子)。如果我們刪除一個紅色節點（此時該節點的兒子將都為葉子節點），它的父親和兒子一定是黑色的。所以我們可以簡單的用它的黑色兒子替換它，並不會破壞性質3和性質4。通過被刪除節點的所有路徑只是少了一個紅色節點，這樣可以繼續保證性質5。另一種簡單情況是在被刪除節點是黑色而它的兒子是紅色的時候。如果只是去除這個黑色節點，用它的紅色兒子頂替上來的話，會破壞性質5，但是如果我們重繪它的兒子為黑色，則曾經通過它的所有路徑將通過它的黑色兒子，這樣可以繼續保持性質5。
需要進一步討論的是在要刪除的節點和它的兒子二者都是黑色的時候，這是一種復雜的情況。我們首先把要刪除的節點替換為它的兒子。出於方便，稱呼這個兒子為N(在新的位置上)，稱呼它的兄弟(它父親的另一個兒子)為S。在下面的示意圖中，我們還是使用P稱呼N的父親，SL稱呼S的左兒子，SR稱呼S的右兒子。
如果N和它初始的父親是黑色，則刪除它的父親導致通過N的路徑都比不通過它的路徑少了一個黑色節點。因為這違反了性質5，樹需要被重新平衡。有幾種情形需要考慮:
情形1: N是新的根。在這種情形下，我們就做完了。我們從所有路徑去除了一個黑色節點，而新根是黑色的，所以性質都保持著。
註意: 在情形2、5和6下，我們假定N是它父親的左兒子。如果它是右兒子，則在這些情形下的左和右應當對調。
情形2: S是紅色。在這種情形下我們在N的父親上做左旋轉，把紅色兄弟轉換成N的祖父，我們接著對調N的父親和祖父的顏色。完成這兩個操作後，盡管所有路徑上黑色節點的數目沒有改變，但現在N有了一個黑色的兄弟和一個紅色的父親（它的新兄弟是黑色因為它是紅色S的一個兒子），所以我們可以接下去按情形4、情形5或情形6來處理。
情形3: N的父親、S和S的兒子都是黑色的。在這種情形下，我們簡單的重繪S為紅色。結果是通過S的所有路徑，它們就是以前不通過N的那些路徑，都少了一個黑色節點。因為刪除N的初始的父親使通過N的所有路徑少了一個黑色節點，這使事情都平衡了起來。但是，通過P的所有路徑現在比不通過P的路徑少了一個黑色節點，所以仍然違反性質5。要修正這個問題，我們要從情形1開始，在P上做重新平衡處理。
情形4: S和S的兒子都是黑色，但是N的父親是紅色。在這種情形下，我們簡單的交換N的兄弟和父親的顏色。這不影響不通過N的路徑的黑色節點的數目，但是它在通過N的路徑上對黑色節點數目增加了一，添補了在這些路徑上刪除的黑色節點。
情形5: S是黑色，S的左兒子是紅色，S的右兒子是黑色，而N是它父親的左兒子。在這種情形下我們在S上做右旋轉，這樣S的左兒子成為S的父親和N的新兄弟。我們接著交換S和它的新父親的顏色。所有路徑仍有同樣數目的黑色節點，但是現在N有了一個黑色兄弟，他的右兒子是紅色的，所以我們進入了情形6。N和它的父親都不受這個變換的影響。
情形6: S是黑色，S的右兒子是紅色，而N是它父親的左兒子。在這種情形下我們在N的父親上做左旋轉，這樣S成為N的父親（P）和S的右兒子的父親。我們接著交換N的父親和S的顏色，並使S的右兒子為黑色。子樹在它的根上的仍是同樣的顏色，所以性質3沒有被違反。但是，N現在增加了一個黑色祖先: 要麽N的父親變成黑色，要麽它是黑色而S被增加為一個黑色祖父。所以，通過N的路徑都增加了一個黑色節點。
此時，如果一個路徑不通過N，則有兩種可能性:
- 它通過N的新兄弟。那麽它以前和現在都必定通過S和N的父親，而它們只是交換了顏色。所以路徑保持了同樣數目的黑色節點。
- 它通過N的新叔父，S的右兒子。那麽它以前通過S、S的父親和S的右兒子，但是現在只通過S，它被假定為它以前的父親的顏色，和S的右兒子，它被從紅色改變為黑色。合成效果是這個路徑通過了同樣數目的黑色節點。
在任何情況下，在這些路徑上的黑色節點數目都沒有改變。所以我們恢復了性質4。在示意圖中的白色節點可以是紅色或黑色，但是在變換前後都必須指定相同的顏色。
紅黑樹實現源碼：
#define BLACK 1
#define RED 0
using namespace std;
class bst {
private:
struct Node {
int value;
bool color;
Node *leftTree, *rightTree, *parent;
Node() {
color = RED;
leftTree = NULL;
rightTree = NULL;
parent = NULL;
value = 0;
}
Node* grandparent() {
if (parent == NULL) {
return NULL;
}
return parent->parent;
}
Node* uncle() {
if (grandparent() == NULL) {
return NULL;
}
if (parent == grandparent()->rightTree)
return grandparent()->leftTree;
else
return grandparent()->rightTree;
}
Node* sibling() {
if (parent->leftTree == this)
return parent->rightTree;
else
return parent->leftTree;
}
};
void rotate_right(Node *p) {
Node *gp = p->grandparent();
Node *fa = p->parent;
Node *y = p->rightTree;
fa->leftTree = y;
if (y != NIL)
y->parent = fa;
p->rightTree = fa;
fa->parent = p;
if (root == fa)
root = p;
p->parent = gp;
if (gp != NULL) {
if (gp->leftTree == fa)
gp->leftTree = p;
else
gp->rightTree = p;
}
}
void rotate_left(Node *p) {
if (p->parent == NULL) {
root = p;
return;
}
Node *gp = p->grandparent();
Node *fa = p->parent;
Node *y = p->leftTree;
fa->rightTree = y;
if (y != NIL)
y->parent = fa;
p->leftTree = fa;
fa->parent = p;
if (root == fa)
root = p;
p->parent = gp;
if (gp != NULL) {
if (gp->leftTree == fa)
gp->leftTree = p;
else
gp->rightTree = p;
}
}
void inorder(Node *p) {
if (p == NIL)
return;
if (p->leftTree)
inorder(p->leftTree);
cout << p->value << " ";
if (p->rightTree)
inorder(p->rightTree);
}
string outputColor(bool color) {
return color ? "BLACK" : "RED";
}
Node* getSmallestChild(Node *p) {
if (p->leftTree == NIL)
return p;
return getSmallestChild(p->leftTree);
}
bool delete_child(Node *p, int data) {
if (p->value > data) {
if (p->leftTree == NIL) {
return false;
}
return delete_child(p->leftTree, data);
} else if (p->value < data) {
if (p->rightTree == NIL) {
return false;
}
return delete_child(p->rightTree, data);
} else if (p->value == data) {
if (p->rightTree == NIL) {
delete_one_child(p);
return true;
}
Node *smallest = getSmallestChild(p->rightTree);
swap(p->value, smallest->value);
delete_one_child(smallest);
return true;
}
}
void delete_one_child(Node *p) {
Node *child = p->leftTree == NIL ? p->rightTree : p->leftTree;
if (p->parent == NULL && p->leftTree == NIL && p->rightTree == NIL) {
p = NULL;
root = p;
return;
}
if (p->parent == NULL) {
delete p;
child->parent = NULL;
root = child;
root->color = BLACK;
return;
}
if (p->parent->leftTree == p) {
p->parent->leftTree = child;
} else {
p->parent->rightTree = child;
}
child->parent = p->parent;
if (p->color == BLACK) {
if (child->color == RED) {
child->color = BLACK;
} else
delete_case(child);
}
delete p;
}
void delete_case(Node *p) {
if (p->parent == NULL) {
p->color = BLACK;
return;
}
if (p->sibling()->color == RED) {
p->parent->color = RED;
p->sibling()->color = BLACK;
if (p == p->parent->leftTree)
rotate_left(p->sibling());
else
rotate_right(p->sibling());
}
if (p->parent->color == BLACK && p->sibling()->color == BLACK
&& p->sibling()->leftTree->color == BLACK && p->sibling()->rightTree->color == BLACK) {
p->sibling()->color = RED;
delete_case(p->parent);
} else if (p->parent->color == RED && p->sibling()->color == BLACK
&& p->sibling()->leftTree->color == BLACK && p->sibling()->rightTree->color == BLACK) {
p->sibling()->color = RED;
p->parent->color = BLACK;
} else {
if (p->sibling()->color == BLACK) {
if (p == p->parent->leftTree && p->sibling()->leftTree->color == RED
&& p->sibling()->rightTree->color == BLACK) {
p->sibling()->color = RED;
p->sibling()->leftTree->color = BLACK;
rotate_right(p->sibling()->leftTree);
} else if (p == p->parent->rightTree && p->sibling()->leftTree->color == BLACK
&& p->sibling()->rightTree->color == RED) {
p->sibling()->color = RED;
p->sibling()->rightTree->color = BLACK;
rotate_left(p->sibling()->rightTree);
}
}
p->sibling()->color = p->parent->color;
p->parent->color = BLACK;
if (p == p->parent->leftTree) {
p->sibling()->rightTree->color = BLACK;
rotate_left(p->sibling());
} else {
p->sibling()->leftTree->color = BLACK;
rotate_right(p->sibling());
}
}
}
void insert(Node *p, int data) {
if (p->value >= data) {
if (p->leftTree != NIL)
insert(p->leftTree, data);
else {
Node *tmp = new Node();
tmp->value = data;
tmp->leftTree = tmp->rightTree = NIL;
tmp->parent = p;
p->leftTree = tmp;
insert_case(tmp);
}
} else {
if (p->rightTree != NIL)
insert(p->rightTree, data);
else {
Node *tmp = new Node();
tmp->value = data;
tmp->leftTree = tmp->rightTree = NIL;
tmp->parent = p;
p->rightTree = tmp;
insert_case(tmp);
}
}
}
void insert_case(Node *p) {
if (p->parent == NULL) {
root = p;
p->color = BLACK;
return;
}
if (p->parent->color == RED) {
if (p->uncle()->color == RED) {
p->parent->color = p->uncle()->color = BLACK;
p->grandparent()->color = RED;
insert_case(p->grandparent());
} else {
if (p->parent->rightTree == p && p->grandparent()->leftTree == p->parent) {
rotate_left(p);
rotate_right(p);
p->color = BLACK;
p->leftTree->color = p->rightTree->color = RED;
} else if (p->parent->leftTree == p && p->grandparent()->rightTree == p->parent) {
rotate_right(p);
rotate_left(p);
p->color = BLACK;
p->leftTree->color = p->rightTree->color = RED;
} else if (p->parent->leftTree == p && p->grandparent()->leftTree == p->parent) {
p->parent->color = BLACK;
p->grandparent()->color = RED;
rotate_right(p->parent);
} else if (p->parent->rightTree == p && p->grandparent()->rightTree == p->parent) {
p->parent->color = BLACK;
p->grandparent()->color = RED;
rotate_left(p->parent);
}
}
}
}
void DeleteTree(Node *p) {
if (!p || p == NIL) {
return;
}
DeleteTree(p->leftTree);
DeleteTree(p->rightTree);
delete p;
}
public:
bst() {
NIL = new Node();
NIL->color = BLACK;
root = NULL;
}
~bst() {
if (root)
DeleteTree(root);
delete NIL;
}
void inorder() {
if (root == NULL)
return;
inorder(root);
cout << endl;
}
void insert(int x) {
if (root == NULL) {
root = new Node();
root->color = BLACK;
root->leftTree = root->rightTree = NIL;
root->value = x;
} else {
insert(root, x);
}
}
bool delete_value(int data) {
return delete_child(root, data);
}
private:
Node *root, *NIL;
};
回到頂部
4. B樹
B樹也是一種用於查找的平衡樹，但是它不是二叉樹。
B樹的定義：B樹（B-tree）是一種樹狀數據結構，能夠用來存儲排序後的數據。這種數據結構能夠讓查找數據、循序存取、插入數據及刪除的動作，都在對數時間內完成。B樹，概括來說是一個一般化的二叉查找樹，可以擁有多於2個子節點。與自平衡二叉查找樹不同，B-樹為系統最優化大塊數據的讀和寫操作。B-tree算法減少定位記錄時所經歷的中間過程，從而加快存取速度。這種數據結構常被應用在數據庫和文件系統的實作上。
在B樹中查找給定關鍵字的方法是，首先把根結點取來，在根結點所包含的關鍵字K1,…,Kn查找給定的關鍵字（可用順序查找或二分查找法），若找到等於給定值的關鍵字，則查找成功；否則，一定可以確定要查找的關鍵字在Ki與Ki+1之間，Pi為指向子樹根節點的指針，此時取指針Pi所指的結點繼續查找，直至找到，或指針Pi為空時查找失敗。
B樹作為一種多路搜索樹（並不是二叉的）：
1) 定義任意非葉子結點最多只有M個兒子；且M>2；
2) 根結點的兒子數為[2, M]；
3) 除根結點以外的非葉子結點的兒子數為[M/2, M]；
4) 每個結點存放至少M/2-1（取上整）和至多M-1個關鍵字；（至少2個關鍵字）
5) 非葉子結點的關鍵字個數=指向兒子的指針個數-1；
6) 非葉子結點的關鍵字：K[1], K[2], …, K[M-1]；且K[i] < K[i+1]；
7) 非葉子結點的指針：P[1], P[2], …, P[M]；其中P[1]指向關鍵字小於K[1]的子樹，P[M]指向關鍵字大於K[M-1]的子樹，其它P[i]指向關鍵字屬於(K[i-1], K[i])的子樹；
8) 所有葉子結點位於同一層；
如下圖為一個M=3的B樹示例：
B樹創建的示意圖：
5. B+樹
B+樹是B樹的變體，也是一種多路搜索樹：
1) 其定義基本與B-樹相同，除了：
2) 非葉子結點的子樹指針與關鍵字個數相同；
3) 非葉子結點的子樹指針P[i]，指向關鍵字值屬於[K[i], K[i+1])的子樹（B-樹是開區間）；
4) 為所有葉子結點增加一個鏈指針；
5) 所有關鍵字都在葉子結點出現；
下圖為M=3的B+樹的示意圖：
B+樹的搜索與B樹也基本相同，區別是B+樹只有達到葉子結點才命中（B樹可以在非葉子結點命中），其性能也等價於在關鍵字全集做一次二分查找；
B+的性質：
1.所有關鍵字都出現在葉子結點的鏈表中（稠密索引），且鏈表中的關鍵字恰好是有序的；
2.不可能在非葉子結點命中；
3.非葉子結點相當於是葉子結點的索引（稀疏索引），葉子結點相當於是存儲（關鍵字）數據的數據層；
4.更適合文件索引系統。
下面為一個B+樹創建的示意圖：
6. B*樹
B*樹是B+樹的變體，在B+樹的非根和非葉子結點再增加指向兄弟的指針，將結點的最低利用率從1/2提高到2/3。
B*樹如下圖所示：
B*樹定義了非葉子結點關鍵字個數至少為(2/3)*M，即塊的最低使用率為2/3（代替B+樹的1/2）；
B+樹的分裂：當一個結點滿時，分配一個新的結點，並將原結點中1/2的數據復制到新結點，最後在父結點中增加新結點的指針；B+樹的分裂只影響原結點和父結點，而不會影響兄弟結點，所以它不需要指向兄弟的指針；
B*樹的分裂：當一個結點滿時，如果它的下一個兄弟結點未滿，那麽將一部分數據移到兄弟結點中，再在原結點插入關鍵字，最後修改父結點中兄弟結點的關鍵字（因為兄弟結點的關鍵字範圍改變了）；如果兄弟也滿了，則在原結點與兄弟結點之間增加新結點，並各復制1/3的數據到新結點，最後在父結點增加新結點的指針；
所以，B*樹分配新結點的概率比B+樹要低，空間使用率更高。
回到頂部7. Trie樹
Tire樹稱為字典樹，又稱單詞查找樹，Trie樹，是一種樹形結構，是一種哈希樹的變種。典型應用是用於統計，排序和保存大量的字符串（但不僅限於字符串），所以經常被搜索引擎系統用於文本詞頻統計。它的優點是：利用字符串的公共前綴來減少查詢時間，最大限度地減少無謂的字符串比較，查詢效率比哈希樹高。
Tire樹的三個基本性質： 1) 根節點不包含字符，除根節點外每一個節點都只包含一個字符； 2) 從根節點到某一節點，路徑上經過的字符連接起來，為該節點對應的字符串； 3) 每個節點的所有子節點包含的字符都不相同。Tire樹的應用：
1) 串的快速檢索
給出N個單詞組成的熟詞表，以及一篇全用小寫英文書寫的文章，請你按最早出現的順序寫出所有不在熟詞表中的生詞。
在這道題中，我們可以用數組枚舉，用哈希，用字典樹，先把熟詞建一棵樹，然後讀入文章進行比較，這種方法效率是比較高的。
2) “串”排序
給定N個互不相同的僅由一個單詞構成的英文名，讓你將他們按字典序從小到大輸出。用字典樹進行排序，采用數組的方式創建字典樹，這棵樹的每個結點的所有兒子很顯然地按照其字母大小排序。對這棵樹進行先序遍歷即可。
3) 最長公共前綴
對所有串建立字典樹，對於兩個串的最長公共前綴的長度即他們所在的結點的公共祖先個數，於是，問題就轉化為求公共祖先的問題。
----------------
作者：Poll的筆記
博客出處：http://www.cnblogs.com/maybe2030/
本文版權歸作者和博客園所有，歡迎轉載，轉載請標明出處。
[轉]數據結構中各種樹