數據結構中各類樹
閱讀目錄html
數據結構中有不少樹的結構，其中包括二叉樹、二叉搜索樹、2-3樹、紅黑樹等等。本文中對數據結構中常見的幾種樹的概念和用途進行了彙總，不求嚴格精準，但求簡單易懂。node
回到頂部算法
1. 二叉樹
二叉樹是數據結構中一種重要的數據結構，也是樹表家族最爲基礎的結構。數據庫
二叉樹的定義：二叉樹的每一個結點至多隻有二棵子樹(不存在度大於2的結點)，二叉樹的子樹有左右之分，次序不能顛倒。二叉樹的第i層至多有2i-1個結點；深度爲k的二叉樹至多有2k-1個結點；對任何一棵二叉樹T，若是其終端結點數爲n0，度爲2的結點數爲n2，則n0=n2+1。數組
二叉樹的示例：數據結構
滿二叉樹和徹底二叉樹：app
滿二叉樹：除最後一層無任何子節點外，每一層上的全部結點都有兩個子結點。也能夠這樣理解，除葉子結點外的全部結點均有兩個子結點。節點數達到最大值，全部葉子結點必須在同一層上。函數
滿二叉樹的性質：性能
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+2i。
2. 二叉查找樹
二叉查找樹定義：又稱爲是二叉排序樹（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; }
刪除操做：
<P> <PRE>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是新的根。在這種情形下，咱們就作完了。咱們從全部路徑去除了一個黑色節點，而新根是黑色的，因此性質都保持着。
注意: 在情形二、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。在示意圖中的白色節點能夠是紅色或黑色，可是在變換先後都必須指定相同的顏色。
紅黑樹實現源碼：
<PRE>#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) 最長公共前綴
對全部串創建字典樹，對於兩個串的最長公共前綴的長度即他們所在的結點的公共祖先個數，因而，問題就轉化爲求公共祖先的問題。
- 1. 數據結構——樹（各類樹）
- 2. [Data Structure] 數據結構中各種樹
- 3. 數據結構中的各種樹
- 4. java 樹結構數據類型_數據結構中的樹類型
- 5. 數據結構中的各類樹淺談
- 6. 數字的森林——各類樹數據結構解析
- 7. 數據結構-各類樹的簡單理解
- 8. 數據結構-樹結構
- 9. 數據結構---樹結構
- 10. 數據結構——樹結構
- 更多相關文章...
- • XML 樹結構 - XML 教程
- • Rust 結構體 - RUST 教程
- • Flink 數據傳輸及反壓詳解
- • TiDB 在摩拜單車在線數據業務的應用和實踐
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. js中 charCodeAt
- 2. Android中通過ViewHelper.setTranslationY實現View移動控制（NineOldAndroids開源項目）
- 3. 【Android】日常記錄：BottomNavigationView自定義樣式，修改點擊後圖片
- 4. maya 文件檢查 ui和數據分離 （一）
- 5. eclipse 修改項目的jdk版本
- 6. Android InputMethod設置
- 7. Simulink中Bus Selector出現很多? ? ?
- 8. 【Openfire筆記】啓動Mac版Openfire時提示「系統偏好設置錯誤」
- 9. AutoPLP在偏好標籤中的生產與應用
- 10. 數據庫關閉的四種方式
- 1. 數據結構——樹（各類樹）
- 2. [Data Structure] 數據結構中各種樹
- 3. 數據結構中的各種樹
- 4. java 樹結構數據類型_數據結構中的樹類型
- 5. 數據結構中的各類樹淺談
- 6. 數字的森林——各類樹數據結構解析
- 7. 數據結構-各類樹的簡單理解
- 8. 數據結構-樹結構
- 9. 數據結構---樹結構
- 10. 數據結構——樹結構