數據結構_樹與二叉樹總結
一、樹
定義
具備n（n≥）個節點的有窮集合D與D上的關係集合R構成的結構T。即T:=(D,R)。html
樹的邏輯表示法：樹形表示、文氏圖表示、凹入表示、嵌套括號表示。java
有序樹、無序樹。node
基本概念
孩子節點、雙親節點、子孫節點、祖先節點、兄弟節點算法
節點的度、樹的度、節點的層次、樹的深度或稱高度。（層次、深度從1起）數組
葉子節點、分支節點、內部節點。（度爲0的節點、度非0的節點，非根分支節點）app
性質
對於度爲k的樹：dom
一、節點數=度數+1ide
二、第i層節點數：k(i-1)，i≥1post
三、高爲i的k叉樹節點數最多：(ki-1)/(k-1)，i≥1性能
四、n個節點的k叉樹深度最小爲：ceil( logk( n(k-1)+1 ) )
存儲結構
多重鏈表：定長鏈節點個數（二叉樹等）、不定長鏈節點個數
三重鏈表：每一個節點三個指針域（第一個孩子節點、雙親節點、第一個兄弟節點）
二、二叉樹
二叉樹是有序樹，有5中基本形態。（度不超過2的樹不必定是二叉樹，由於二叉樹還要求左右子樹有序不能顛倒）
n個節點能夠構建卡特蘭數 f(n)= (k=1~n)Σ(f(k-1)f(n-k)) = (C2n n)/(n+1) ，f(0)=f(1)=1種形態的二叉樹。對於有n個節點的有序序列，其BST樹也是卡特蘭數種。
性質
一、節點數=度數+1
二、第i層節點數：2(i-1)，i≥1
三、高爲i的二叉樹節點數最多：2i-1，i≥1
四、n個節點的二叉樹深度最小爲：ceil( log2(n+1) )，爲理想平衡二叉樹時取最小值
五、度爲0的節點數=度爲2的節點數+1。（由於 節點數n=n0+n1+n2 且 分支數 n-1=n1+2n2，聯立可得之）
六、n個節點的徹底二叉樹從1起對節點從上到下從左到右的編號，編號爲i的節點：父節點編號爲 floor(i/2)，除非該節點已爲父節點；左孩子節點編號爲2i，除非2i>n即該節點已爲葉子節點；右孩子編號爲2i+1，除非2i+1>n即右孩子不存在。
推而廣之，對於徹底m叉樹編號爲i的節點，其父節點編號爲 floor((i+m-2)/m ) ，第j個孩子編號爲 mi+j-m+1 。
存儲
一、順序存儲：數組。（適用於徹底二叉樹的存儲，通常二叉樹能夠經過填充虛擬節點當成徹底二叉樹來存儲。缺點是浪費空間）
二、鏈式存儲：
二叉鏈表（左孩子、右孩子）：n個節點的二叉樹有n+1個空指針域（空指針域即2n0+n1=n2+1+n0+n1=n+1）。線索二叉樹經過利用空指針域指向直接前驅、後繼節點來避免遍歷時使用堆棧，如中序線索二叉樹。
三叉鏈表（父節點、左孩子、右孩子）
創建
根據輸入的序列構創建用二叉鏈表存儲的二叉樹。這裏假定序列爲字符串，每一個字符對應樹中一個節點。
輸入：
首先說下補空，由輸入序列（前綴、中綴、後綴皆可）構建二叉樹時，若是序列裏沒有標記一些節點結束信息，則因爲沒法識別結束或哪些是葉節點從而不能由序列構建出樹。所謂補空就是在序列中加入一些特殊字符如'#'，加在哪？方式1：一般是序列對應的樹的節點的空指針域中，也即度爲1和0的節點的空孩子，此時對於n個節點的序列其補空數爲n+1；方式2：也能夠只對度爲1的節點補空。有趣的是若是輸入序列是表達式，則用前種補空方式時只有葉節點即操做數補空、用後種補空時沒有節點被補空。一般用前種方式補空，某些特殊狀況下才用後者。
加括號：把根節點和其左右子樹當作一體，在其外圍加上括號。
百言不如一圖，樹T按方式一、2分別被補空爲T一、T2：
對輸入序列：由單一序列就想構建二叉樹則須要序列包含補空信息或序列自己包含額外信息（如前綴表達式序列操做符爲內部節點操做數爲葉節點），要下不補空就能構建二叉樹則需多個序列。
總結：（帶括號補空：前、中、後序遞歸; 不帶括號補空：前序遞歸、後序非遞歸、層次非遞歸； 不帶括號不補空：先後綴表達式、前中序、中後序等），其中，由 不帶括號內補空層次序列 構建二叉樹最直觀最適用，如LeetCode中與樹有關的題目的輸入。
一、一般而言，輸入序列裏須要包含補空信息，此時可採用 前序、中序、後序 遍歷輸入序列來創建二叉樹，只要構建過程遍歷採用的序與輸入序列採用的序同樣。分爲兩種狀況：
1）帶括號的補空序列（方式1或2）（可按方式1或2補空，無論是T一、T2，有幾個內部節點就有幾個括號，即爲T的節點數或內部節點數）
a、帶括號、補空，前序序列（遞歸構建）：
1 void createPreOrder_withBrackets(char prefix[],BTREE &T) 2 { 3 //要求輸入的前綴序列帶括號 ，並含有對度爲0和1的節點的補空特殊字符。此時非特殊字符都成了「內部節點」，有幾個非特殊字符就有幾個括號。 4 //固然也能夠只對度爲1的補空，此時有幾個非葉節點的非特殊字符就有幾個括號。若輸入的是前綴表達式，則此狀況的內部節點其實就是操做符，葉節點是操做數。 5 //例子：度爲0和1的補空：( A( B( D##) ( E( G#( H##) ) #) ) ( C( F##) #) )，只對度爲1的補空：( A( BD( E( G#H )# ) )( CF# ) ) 6 //特殊例子(前綴表達式)：度爲0和1的補空：( *( +( A##) ( /( -( B##) ( C##) ) ( D##) ) ) ( E##) ) ，只對度爲1的補空：(*(+A(/(-BC)D))E) 7 char x=nextToken(prefix); 8 9 if(x=='#') 10 { 11 T=NULL; 12 } 13 else 14 { 15 T=(BTREE)malloc(sizeof(BTNode)); 16 T->lchild=NULL; 17 T->rchild=NULL; 18 19 if(x=='(') 20 {//處理括號裏的表達式 21 x=nextToken(prefix);//表達式的操做符 22 T->data=x; 23 24 createPreOrder_withBrackets(prefix,T->lchild);//表達式的左操做數 25 26 createPreOrder_withBrackets(prefix,T->rchild);//表達式的右操做數 27 28 nextToken(prefix);//右括號 29 } 30 else 31 { 32 T->data=x; 33 } 34 } 35 }
若輸入按方式1補空，則括號數爲T1的內部節點數即T的節點數，如 ( *( +( A##) ( /( -( B##) ( C##) ) ( D##) ) ) ( E##) ) 、 ( A( B( D##) ( E( G#( H##) ) #) ) ( C( F##) #) ) ；
若輸入按方式2補空，則括號數爲T2的內部節點數即T的內部節點數。如 (*(+A(/(-BC)D))E) 、 ( A( BD( E( G#H )# ) )( CF# ) ) ，能夠發現前者就是前綴表達式，只不過多了括號。
能夠發現，不論哪一種補空方式，括號數都是補空後的樹的內部節點數。想一想，表達式樹的內部節點都是操做符葉節點都是操做數，其中綴表達式的括號數就是操做符（內部節點）數，與這裏的括號數有何聯繫？
b、帶括號、補空，中序序列（遞歸構建）：與上相似，改變一行代碼順序便可。
c、帶括號、補空，中序序列（遞歸構建）：一樣，改變一行代碼順序便可。
輸入示例：
|--------------------------------------------------------------------------------------------------------------------------------------------|
| 方式1：度爲一、0的節點補空 | 方式2：度爲1的節點補空 |
| 前綴：( *( +( A##) ( /( -( B##) ( C##) ) ( D##) ) ) ( E##) ) | (*(+A(/(-BC)D))E) |
| 示例1 中綴：( ( ( #A#) +( ( ( #B#) -( #C#) ) /( #D#) ) ) *( #E#) ) | ((A+((B-C)/D))*E) |
| 後綴：(((##A)(((##B)(##C)-)(##D)/)+)(##E)*) | ((A((BC-)D/)+)E*) |
|---------------------------------------------------------------------------------------------------------------------------------------------|
| 前綴：( A( B( D##) ( E( G#( H##) ) #) ) ( C( F##) #) ) | ( A( BD( E( G#H )# ) )( CF# ) ) |
| 示例2 中綴：( ( ( #D#) B( ( #G( #H#) ) E#) ) A( ( #F#) C#) ) | ( ( DB( ( #GH )E# ) )A( FC# ) ) |
| 後綴：(((##D)((#(##H)G)#E)B)((##F)#C)A) | ( ( D( ( #HG )#E )B )( F#C )A ) |
|_____________________________________________________________________________________|
能夠發現，此種方法能對帶括號的中綴表達式構建表達式樹。
2）不帶括號的補空序列（只能方式1）。實際上本方式使用得最多，加括號是爲了程序解析但不利於人閱讀，括號數一多不信你不會被搞蒙。。。
a、不帶括號、全補空、前序序列（遞歸構建）：
1 void createPreOrder(char prefixStr[],BTREE &T) 2 { 3 char x=nextToken(prefixStr); 4 if(x=='#') 5 { 6 T=NULL; 7 } 8 else 9 { 10 T=(BTREE)malloc(sizeof(BTNode)); 11 T->data=x; 12 createPreOrder(prefixStr,T->lchild); 13 createPreOrder(prefixStr,T->rchild); 14 } 15 }
輸入示例（上表第一列前序者去掉括號便可）： +A##/-B##C##D##E## 、 AB D## E G# H### C F## #
b、不帶括號，全補空、中序序列，能夠發現參數無論什麼中序序列補空後每一個字符左右均爲#，因此其對應的樹不惟一，故不帶括號的中序補空序列無法構建樹。
c、不帶括號、全補空、後序序列（非遞歸構建）：每遇到一個非補空字符時爲之建立一個新節點並從棧中取兩個節點做爲其孩子
1 void createPostOrder(char infix[],BTREE &T) 2 {// 3 int stackSize=100; 4 BTREE stack[stackSize],p; 5 int top=-1; 6 char x; 7 while(1) 8 { 9 x=nextToken(infix); 10 if(x=='\0') 11 { 12 break; 13 } 14 else if(x=='#') 15 { 16 stack[++top]=NULL; 17 } 18 else 19 { 20 p=(BTREE)malloc(sizeof(BTNode)); 21 p->data=x; 22 p->lchild=stack[top-1];; 23 p->rchild=stack[top]; 24 stack[top-1]=p; 25 top--; 26 } 27 } 28 T=stack[0]; 29 }
輸入示例（上表第一列後序者去掉括號便可）
d、不帶括號、按徹底二叉樹形式補空、層次遍歷序列（非遞歸構建）
1 void createLayerOrder(char layerSeq[],int n,BTREE &T) 2 {//輸入序列是廣度優先序列，且按徹底二叉樹形式補空，由於要利用父子節點間編號的關係。如 "12#34#####5" 3 if(n<0) return; 4 5 BTREE node[n]; 6 int i,j; 7 for(i=0;i<n;i++) 8 { 9 if(layerSeq[i]!='#') 10 { 11 node[i]=(BTREE)malloc(sizeof(BTNode)); 12 node[i]->data=layerSeq[i]; 13 node[i]->lchild=NULL; 14 node[i]->rchild=NULL; 15 if(i==0) 16 { 17 T=node[i]; 18 } 19 else 20 { 21 j=(i-1)/2;//父節點下標 22 if(2*j+1==i)node[j]->lchild=node[i];//當前節點是父節點的左孩子 23 else node[j]->rchild=node[i] ;//當前節點是父節點的右孩子 24 } 25 } 26 } 27 }
e、不帶括號、內補空、層次序列，最直接最經常使用
將內補空序列轉爲徹底二叉樹形式補空序列，而後按d處理或直接在轉換的過程當中創建：
1 //輸入層次遍歷序列（內補空），構建二叉樹 2 void createLayerOrder2(char layerSeq[],int n,BTREE &T) 3 { 4 //先將序列轉爲徹底二叉樹形式補空的序列 5 const int M=100; 6 7 if(n<=0) return; 8 9 char input[M];//node[]用於以徹底二叉樹形式存儲節點 10 BTREE node[M]; 11 12 int i=0,nonBlank=0; 13 while(i<n) 14 {//統計非空字符數，做爲下面循環結束的條件 15 input[i]=layerSeq[i]; 16 if(input[i]!='#') 17 { 18 nonBlank++; 19 } 20 i++; 21 } 22 23 i=0; 24 int j; 25 while(nonBlank>0) 26 { 27 if(input[i]!='#') 28 { 29 nonBlank--; 30 {//法1，轉換爲徹底二叉樹補空形式過程當中構建 31 node[i]=(BTREE)malloc(sizeof(BTNode)); 32 node[i]->data=input[i]; 33 node[i]->lchild=NULL; 34 node[i]->rchild=NULL; 35 if(i==0) 36 { 37 T=node[i]; 38 } 39 else 40 { 41 j=(i-1)/2; 42 if(2*j+1==i)node[j]->lchild=node[i]; 43 else if(2*j+2==i) node[j]->rchild=node[i]; 44 } 45 } 46 } 47 else 48 { 49 //後移兩位 50 for(j=n-1;j>=2*i+1;j--) 51 { 52 input[j+2]=input[j]; 53 } 54 n+=2; 55 input[2*i+1]='#'; 56 input[2*i+2]='#'; 57 } 58 i++; 59 } 60 61 62 {//法2，調用，根據徹底二叉樹形式補空序列構建二叉樹 63 // input[n]='\0'; 64 // printf("%s\n",input); 65 // createLayerOrder(input,n,T) ;//輸入二叉樹形式補空的序列，構建二叉樹 66 } 67 }
二、要想輸入時不需補空：
1）要麼同時提供中序、前序序列 或 同時提供中序、後序序列 或 同時提供中序、層次序列。
法一（三種都可用此法）：根據中序序列下標採用逐點插入法構建「二叉搜索樹」——前序、層次序列從頭至尾各元素依次插入；後序序列從後到前各元素依次插入。
1 //根據 中序序列 和 後序|前序|層次序列 構建二叉樹。採用逐點插入法構建「二叉搜索樹」。 2 int cbiGetIndex(char inorder[],int n,char val) 3 {//獲取給定值在中序序列的下標 4 int i=0; 5 while(i<n && inorder[i]!=val) 6 { 7 i++; 8 } 9 return i; 10 } 11 void cbiBuildBST(BTREE &T,char inorder[],int n,char val) 12 {//插入一個值到二叉搜索樹 13 if(T==NULL) 14 { 15 T=(BTREE)malloc(sizeof(BTNode)); 16 T->data=val; 17 T->lchild=NULL; 18 T->rchild=NULL; 19 } 20 else if(cbiGetIndex(inorder,n,val) < cbiGetIndex(inorder,n,T->data)) 21 { 22 cbiBuildBST(T->lchild,inorder,n,val); 23 } 24 else 25 { 26 cbiBuildBST(T->rchild,inorder,n,val); 27 } 28 } 29 void createByInAndOtherOrder(BTREE &T,char input[],int isInputPostOrder,char inorder[],int n) 30 {//根據 中序序列 和 後序|前序|層次序列 構建二叉樹。採用逐點插入法構建「二叉搜索樹」。 31 printf("%s %d\n",input,n); 32 int i; 33 if(isInputPostOrder) 34 {//若input是後序序列，從後往前依次插入各元素 35 for(i=n-1;i>=0;i--) 36 { 37 cbiBuildBST(T,inorder,n,input[i]); 38 } 39 } 40 else{//不然input是前序或後序序列，從前日後依次插入各元素 41 for(i=0;i<n;i++) 42 { 43 cbiBuildBST(T,inorder,n,input[i]); 44 } 45 } 46 }
法二（前兩種可用此法）：取前序序列首元素，找到在中序序列的位置，此位置分割成的左右兩部分就是左子樹和右子樹，兩部分的長度分別對應前序序列接下來兩部分的長度，遞歸進行。
a、由前序、中序序列構建二叉樹：（不帶括號、不補空、遞歸構建）。
1 //由前序、中序序列（不補空不帶括號）構建二叉樹。有重複元素的話樹不惟一，因此不能有重 2 void createByPreInOrder(BTREE &T,char preorder[],int preStart,int preEnd,char inorder[],int inStart,int inEnd) 3 {//求前序序列首元素在中序序列的位置，此位置左邊爲左子樹序列、右邊爲右子樹序列，二者的長度分別對應前序序列接下來的兩段長度，接下來遞歸進行。 4 if(preStart>preEnd || inStart>inEnd || preEnd-preStart!=inEnd-inStart) 5 { 6 return; 7 } 8 9 //求前序序列首元素在中序序列的位置 及 中序序列被該元素分紅的左右子序列的長度 10 int pivot; 11 for(pivot=inStart; pivot<=inEnd && preorder[preStart]!=inorder[pivot];pivot++); 12 int leftLen=pivot-inStart;//位置左邊的元素個數 13 int rightLen=inEnd-pivot;//位置右邊的元素個數 14 15 T=(BTREE)malloc(sizeof(BTNode)); 16 T->data=preorder[preStart]; 17 T->lchild=NULL; 18 T->rchild=NULL; 19 if(leftLen>0) 20 { 21 createByPreInOrder(T->lchild,preorder, preStart+1, preStart+1+leftLen-1, inorder, inStart, pivot-1); 22 } 23 if(rightLen>0) 24 { 25 createByPreInOrder(T->rchild,preorder, preStart+1+leftLen, preEnd, inorder, pivot+1, inEnd); 26 } 27 }
b、由後序、中序序列構建二叉樹：（不帶括號、不補空、遞歸構建）。與上述相似，只不過每次取的是後序序列的末尾值來構建新節點
1 //由後序、中序序列（不補空不帶括號）構建二叉樹。有重複元素的話樹不惟一，因此不能有重 2 void createByPostInOrder(BTREE &T,char postorder[],int postStart,int postEnd,char inorder[],int inStart,int inEnd) 3 {//求後序序列末元素在中序序列的位置，此位置左邊爲左子樹序列、右邊爲右子樹序列，二者的長度分別對應後序序列從首元素開始的兩段長度，接下來遞歸進行。 4 if(postStart>postEnd || inStart>inEnd || postEnd-postStart!=inEnd-inStart) 5 { 6 return; 7 } 8 9 //求前序序列首元素在中序序列的位置 及 中序序列被該元素分紅的左右子序列的長度 10 int pivot; 11 for(pivot=inStart; pivot<=inEnd && postorder[postEnd]!=inorder[pivot];pivot++); 12 int leftLen=pivot-inStart; 13 int rightLen=inEnd-pivot; 14 15 T=(BTREE)malloc(sizeof(BTNode)); 16 T->data=postorder[postEnd]; 17 T->lchild=NULL; 18 T->rchild=NULL; 19 if(leftLen>0) 20 { 21 createByPostInOrder(T->lchild,postorder, postStart, postStart+leftLen-1, inorder, inStart, pivot-1); 22 } 23 if(rightLen>0) 24 { 25 createByPostInOrder(T->rchild,postorder, postStart+leftLen, postEnd-1, inorder, pivot+1, inEnd); 26 } 27 }
注意：
若提供了二叉查找樹的後序遍歷序列則便可構建出該樹，由於二叉查找樹的中序序列是遞增的，咱們能夠從後序序列獲得中序序列；實際上，不獲取也可，從後往前依次將每一個元素插入便可。（給定BST的前序序列時與此相似）。此時其實是上述法一的特殊狀況。
2）要麼序列自己包含額外信息：如前綴表達式或後綴表達式因操做符爲內部節點操做數爲葉節點，可直接根據序列之構建表達式樹；帶括號的中綴表達式（每一個運算符都有對應的括號）括號能提供額外信息，所以也能直接根據之創建樹。
由表達式序列構建表達式樹示例：由表達式序列構建表達式樹-MarchOn （前綴、中綴遞歸，後綴非遞歸）
a、前綴表達式序列構建表達式樹（不帶括號、不補空、遞歸構建）：
1 void createPrefix_recursive(char prefix[],BTREE &T) 2 {//遞歸方式_由前綴表達式構建表達式樹，輸入示例：*+A/-BCDE 3 char x=nextToken(prefix); 4 5 T=(BTREE)malloc(sizeof(BTNode)); 6 T->data=x; 7 T->lchild=NULL; 8 T->rchild=NULL; 9 10 if(!isOpNum(x))//是操做符。前綴表達式的最後一個字符必定是操做數，因此下面的遞歸會中止。 11 { 12 createPrefix_recursive(prefix,T->lchild); 13 createPrefix_recursive(prefix,T->rchild); 14 } 15 }
輸入示例： *+A/-BCDE
b、中綴表達式序列構建表達式樹（帶括號、不補空，遞歸構建）：直接用帶括號補空的方法（一、一、b）中的方法。不過因爲表達式樹內部節點爲操做符葉子節點爲操做數不存在爲度爲1的節點，因此構建方法能夠稍微簡化：
1 void createInfix_recursive(char infix[],BTREE &T) 2 {//遞歸方式_由中綴表達式構建表達式樹，要求輸入的中綴表達式加括號，有幾個操做數就幾個括號 3 char x=nextToken(infix); 4 5 T=(BTREE)malloc(sizeof(BTNode)); 6 T->lchild=NULL; 7 T->rchild=NULL; 8 9 if(x=='(') 10 {//處理括號裏的表達式 11 createInfix_recursive(infix,T->lchild);//表達式的左操做數 12 13 x=nextToken(infix);//表達式的操做符 14 T->data=x; 15 16 createInfix_recursive(infix,T->rchild);//表達式的右操做數 17 nextToken(infix);//右括號 18 } 19 else 20 { 21 T->data=x; 22 } 23 }
輸入示例： ((A+((B-C)/D))*E)
c、後綴表達式序列構建表達式樹（不帶括號、不補空，非遞歸構建）：
1 #define M 100 2 void createPostfix_nonrecursive(char postfix[],BTREE &T) 3 {//非遞歸方式_由後綴表達式構建表達式樹 4 BTREE stack[M],p; 5 int top=-1; 6 char x; 7 while(1) 8 { 9 x=nextToken(postfix); 10 if(x=='\0') 11 { 12 break; 13 } 14 15 p=(BTREE)malloc(sizeof(BTNode)) ; 16 p->data=x; 17 p->lchild=NULL; 18 p->rchild=NULL; 19 20 if(isOpNum(x)) 21 {//操做數 22 stack[++top]=p; 23 } 24 else 25 {//操做符 26 p->lchild=stack[top-1]; 27 p->rchild=stack[top]; 28 stack[top-1]=p; 29 top--; 30 } 31 } 32 T=stack[0]; 33 }
輸入示例： ABC-D/+E*
這裏總結了根據不一樣輸入形式構建二叉樹的方法，當遇到不是這些形式的時，能夠向這些形式靠。如A( (B ( D,E(G)), C(F(,H) ) ) )
可是，也不要那麼死板侷限於這裏的方法，條條大路通羅馬，確定還會有其餘方法的。
附：上述關於樹建立的完整代碼：
1 #include<stdio.h> 2 #include<malloc.h> 3 typedef struct node 4 { 5 int data; 6 struct node* lchild; 7 struct node* rchild; 8 }BTNode,*BTREE; 9 10 11 //遍歷 12 13 void searchPrefix(BTREE T) 14 { 15 if(T!=NULL) 16 { 17 printf("%c",T->data); 18 19 searchPrefix(T->lchild); 20 21 searchPrefix(T->rchild); 22 } 23 } 24 void searchInfix(BTREE T) 25 { 26 if(T!=NULL) 27 {//訪問到內部節點時左右加括號 ，所以幾個內部節點就有幾個括號，若是樹是表達式樹 ，則獲得了帶括號的中綴表達式 28 // if(T->lchild!=NULL || T->rchild!=NULL){ printf("( "); } 29 searchInfix(T->lchild); 30 // if((T->lchild!=NULL || T->rchild!=NULL) && (T->lchild==NULL)){ printf("#"); }//內部節點的空孩子用特殊符號代替 31 32 printf("%c",T->data); 33 34 searchInfix(T->rchild); 35 // if((T->lchild!=NULL || T->rchild!=NULL) && (T->rchild==NULL)){ printf("#"); }//內部節點的空孩子用特殊符號代替 36 // if(T->lchild!=NULL || T->rchild!=NULL){ printf(" )"); } 37 } 38 } 39 void searchPostfix(BTREE T) 40 { 41 if(T!=NULL) 42 {//訪問到內部節點時左右加括號 ，所以幾個內部節點就有幾個括號，若是樹是表達式樹 ，則獲得了帶括號的後綴表達式 43 // if(T->lchild!=NULL || T->rchild!=NULL){ printf("( "); } 44 searchPostfix(T->lchild); 45 // if((T->lchild!=NULL || T->rchild!=NULL) && (T->lchild==NULL)){ printf("#"); }//內部節點的空孩子用特殊符號代替 46 47 searchPostfix(T->rchild); 48 // if((T->lchild!=NULL || T->rchild!=NULL) && (T->rchild==NULL)){ printf("#"); }//內部節點的空孩子用特殊符號代替 49 50 printf("%c",T->data); 51 // if(T->lchild!=NULL || T->rchild!=NULL){ printf(" )"); } 52 } 53 } 54 55 56 //構建 57 char nextToken(char str[]) //讀取下一字符，略過空格 58 { 59 static int pos=0; 60 while(str[pos]!='\0' && str[pos]==' '){ pos++; } 61 return str[pos++]; 62 } 63 64 65 void createPreOrder_withBrackets_c(char prefix[],BTREE *T) 66 {//爲了能更改T，這裏採用了指針，爲了更清晰簡潔，能夠用C++裏的引用 67 char x=nextToken(prefix); 68 69 if(x=='#') 70 { 71 *T=NULL; 72 } 73 else 74 { 75 *T=(BTREE)malloc(sizeof(BTNode)); 76 (*T)->lchild=NULL; 77 (*T)->rchild=NULL; 78 79 if(x=='(') 80 {//處理括號裏的表達式 81 x=nextToken(prefix);//表達式的操做符 82 (*T)->data=x; 83 84 createPreOrder_withBrackets_c(prefix,&((*T)->lchild));//表達式的左操做數 85 86 createPreOrder_withBrackets_c(prefix,&((*T)->rchild));//表達式的右操做數 87 88 nextToken(prefix);//右括號 89 } 90 else 91 { 92 (*T)->data=x; 93 } 94 } 95 } 96 97 void createPreOrder_withBrackets(char prefix[],BTREE &T) 98 { 99 //要求輸入的前綴序列帶括號 ，並含有對度爲0和1的節點的補空特殊字符。此時非特殊字符都成了「內部節點」，有幾個非特殊字符就有幾個括號。 100 //固然也能夠只對度爲1的補空，此時有幾個非葉節點的非特殊字符就有幾個括號。若輸入的是前綴表達式，則此狀況的內部節點其實就是操做符，葉節點是操做數。 101 //例子：度爲0和1的補空：( A( B( D##) ( E( G#( H##) ) #) ) ( C( F##) #) )，只對度爲1的補空：( A( BD( E( G#H )# ) )( CF# ) ) 102 //特殊例子(前綴表達式)：度爲0和1的補空：( *( +( A##) ( /( -( B##) ( C##) ) ( D##) ) ) ( E##) ) ，只對度爲1的補空：(*(+A(/(-BC)D))E) 103 char x=nextToken(prefix); 104 105 if(x=='#') 106 { 107 T=NULL; 108 } 109 else 110 { 111 T=(BTREE)malloc(sizeof(BTNode)); 112 T->lchild=NULL; 113 T->rchild=NULL; 114 115 if(x=='(') 116 {//處理括號裏的表達式 117 x=nextToken(prefix);//表達式的操做符 118 T->data=x; 119 120 createPreOrder_withBrackets(prefix,T->lchild);//表達式的左操做數 121 122 createPreOrder_withBrackets(prefix,T->rchild);//表達式的右操做數 123 124 nextToken(prefix);//右括號 125 } 126 else 127 { 128 T->data=x; 129 } 130 } 131 } 132 133 void createInOrder_withBrackets(char infix[],BTREE &T) 134 {//要求輸入的序列帶括號 ，內部節點才帶括號；度爲1的節點缺失的孩子補特殊字符（度爲0的可補可不補） 135 char x=nextToken(infix); 136 137 if(x=='#') 138 { 139 T=NULL; 140 } 141 else 142 { 143 T=(BTREE)malloc(sizeof(BTNode)); 144 T->lchild=NULL; 145 T->rchild=NULL; 146 147 if(x=='(') 148 {//處理括號裏的表達式 149 createInOrder_withBrackets(infix,T->lchild);//表達式的左操做數 150 151 x=nextToken(infix);//表達式的操做符 152 T->data=x; 153 154 createInOrder_withBrackets(infix,T->rchild);//表達式的右操做數 155 156 nextToken(infix);//右括號 157 } 158 else 159 { 160 T->data=x; 161 } 162 } 163 } 164 165 void createPostOrder_withBrackets(char infix[],BTREE &T) 166 {//要求輸入的序列帶括號 ，內部節點才帶括號；度爲1的節點缺失的孩子補特殊字符（度爲0的可補可不補） 167 char x=nextToken(infix); 168 169 if(x=='#') 170 { 171 T=NULL; 172 } 173 else 174 { 175 T=(BTREE)malloc(sizeof(BTNode)); 176 T->lchild=NULL; 177 T->rchild=NULL; 178 179 if(x=='(') 180 {//處理括號裏的表達式 181 createPostOrder_withBrackets(infix,T->lchild);//表達式的左操做數 182 183 createPostOrder_withBrackets(infix,T->rchild);//表達式的右操做數 184 185 x=nextToken(infix);//表達式的操做符 186 T->data=x; 187 188 nextToken(infix);//右括號 189 } 190 else 191 { 192 T->data=x; 193 } 194 } 195 } 196 197 void createPreOrder(char prefixStr[],BTREE &T) 198 {//輸入序列爲 全補空、不帶括號 的序列 199 char x=nextToken(prefixStr); 200 if(x=='#') 201 { 202 T=NULL; 203 } 204 else 205 { 206 T=(BTREE)malloc(sizeof(BTNode)); 207 T->data=x; 208 createPreOrder(prefixStr,T->lchild); 209 createPreOrder(prefixStr,T->rchild); 210 } 211 } 212 213 214 void createPostOrder(char infix[],BTREE &T) 215 {// 輸入序列爲 全補空、不帶括號 的序列 216 int stackSize=100; 217 BTREE stack[stackSize],p; 218 int top=-1; 219 char x; 220 while(1) 221 { 222 x=nextToken(infix); 223 if(x=='\0') 224 { 225 break; 226 } 227 else if(x=='#') 228 { 229 stack[++top]=NULL; 230 } 231 else 232 { 233 p=(BTREE)malloc(sizeof(BTNode)); 234 p->data=x; 235 p->lchild=stack[top-1];; 236 p->rchild=stack[top]; 237 stack[top-1]=p; 238 top--; 239 } 240 } 241 T=stack[0]; 242 } 243 244 //輸入層次遍歷序列（全補空），構建二叉樹 245 void createLayerOrder(char layerSeq[],int n,BTREE &T) 246 {//輸入序列是廣度優先序列，且按徹底二叉樹形式補空，由於要利用父子節點間編號的關係。如 "12#34#####5" 247 //構建後的實際節點數≤n 248 if(n<=0) return; 249 250 BTREE node[n]; 251 int i,j; 252 for(i=0;i<n;i++) 253 { 254 if(layerSeq[i]!='#') 255 { 256 node[i]=(BTREE)malloc(sizeof(BTNode)); 257 node[i]->data=layerSeq[i]; 258 node[i]->lchild=NULL; 259 node[i]->rchild=NULL; 260 if(i==0) 261 { 262 T=node[i]; 263 } 264 else 265 { 266 j=(i-1)/2;//父節點下標 267 if(2*j+1==i)node[j]->lchild=node[i];//當前節點是父節點的左孩子 268 else node[j]->rchild=node[i] ;//當前節點是父節點的右孩子 269 } 270 } 271 } 272 } 273 274 //輸入層次遍歷序列（內補空），構建二叉樹 275 void createLayerOrder2(char layerSeq[],int n,BTREE &T) 276 { 277 //先將序列轉爲徹底二叉樹形式補空的序列 278 const int M=100; 279 280 if(n<=0) return; 281 282 char input[M];//node[]用於以徹底二叉樹形式存儲節點 283 BTREE node[M]; 284 285 int i=0,nonBlank=0; 286 while(i<n) 287 {//統計非空字符數，做爲下面循環結束的條件 288 input[i]=layerSeq[i]; 289 if(input[i]!='#') 290 { 291 nonBlank++; 292 } 293 i++; 294 } 295 296 i=0; 297 int j; 298 while(nonBlank>0) 299 { 300 if(input[i]!='#') 301 { 302 nonBlank--; 303 {//法1，轉換爲徹底二叉樹補空形式過程當中構建 304 node[i]=(BTREE)malloc(sizeof(BTNode)); 305 node[i]->data=input[i]; 306 node[i]->lchild=NULL; 307 node[i]->rchild=NULL; 308 if(i==0) 309 { 310 T=node[i]; 311 } 312 else 313 { 314 j=(i-1)/2; 315 if(2*j+1==i)node[j]->lchild=node[i]; 316 else if(2*j+2==i) node[j]->rchild=node[i]; 317 } 318 } 319 } 320 else 321 { 322 //後移兩位 323 for(j=n-1;j>=2*i+1;j--) 324 { 325 input[j+2]=input[j]; 326 } 327 n+=2; 328 input[2*i+1]='#'; 329 input[2*i+2]='#'; 330 } 331 i++; 332 } 333 334 335 {//法2，調用，根據徹底二叉樹形式補空序列構建二叉樹 336 // input[n]='\0'; 337 // printf("%s\n",input); 338 // createLayerOrder(input,n,T) ;//輸入二叉樹形式補空的序列，構建二叉樹 339 } 340 } 341 342 //由前序、中序序列（不補空不帶括號）構建二叉樹。有重複元素的話樹不惟一，因此不能有重 343 void createByPreInOrder(BTREE &T,char preorder[],int preStart,int preEnd,char inorder[],int inStart,int inEnd) 344 {//求前序序列首元素在中序序列的位置，此位置左邊爲左子樹序列、右邊爲右子樹序列，二者的長度分別對應前序序列接下來的兩段長度，接下來遞歸進行。 345 if(preStart>preEnd || inStart>inEnd || preEnd-preStart!=inEnd-inStart) 346 { 347 return; 348 } 349 350 //求前序序列首元素在中序序列的位置 及 中序序列被該元素分紅的左右子序列的長度 351 int pivot; 352 for(pivot=inStart; pivot<=inEnd && preorder[preStart]!=inorder[pivot];pivot++); 353 int leftLen=pivot-inStart;//位置左邊的元素個數 354 int rightLen=inEnd-pivot;//位置右邊的元素個數 355 356 T=(BTREE)malloc(sizeof(BTNode)); 357 T->data=preorder[preStart]; 358 T->lchild=NULL; 359 T->rchild=NULL; 360 if(leftLen>0) 361 { 362 createByPreInOrder(T->lchild,preorder, preStart+1, preStart+1+leftLen-1, inorder, inStart, pivot-1); 363 } 364 if(rightLen>0) 365 { 366 createByPreInOrder(T->rchild,preorder, preStart+1+leftLen, preEnd, inorder, pivot+1, inEnd); 367 } 368 } 369 370 //由後序、中序序列（不補空不帶括號）構建二叉樹。有重複元素的話樹不惟一，因此不能有重 371 void createByPostInOrder(BTREE &T,char postorder[],int postStart,int postEnd,char inorder[],int inStart,int inEnd) 372 {//求後序序列末元素在中序序列的位置，此位置左邊爲左子樹序列、右邊爲右子樹序列，二者的長度分別對應後序序列從首元素開始的兩段長度，接下來遞歸進行。 373 if(postStart>postEnd || inStart>inEnd || postEnd-postStart!=inEnd-inStart) 374 { 375 return; 376 } 377 378 //求前序序列首元素在中序序列的位置 及 中序序列被該元素分紅的左右子序列的長度 379 int pivot; 380 for(pivot=inStart; pivot<=inEnd && postorder[postEnd]!=inorder[pivot];pivot++); 381 int leftLen=pivot-inStart; 382 int rightLen=inEnd-pivot; 383 384 T=(BTREE)malloc(sizeof(BTNode)); 385 T->data=postorder[postEnd]; 386 T->lchild=NULL; 387 T->rchild=NULL; 388 if(leftLen>0) 389 { 390 createByPostInOrder(T->lchild,postorder, postStart, postStart+leftLen-1, inorder, inStart, pivot-1); 391 } 392 if(rightLen>0) 393 { 394 createByPostInOrder(T->rchild,postorder, postStart+leftLen, postEnd-1, inorder, pivot+1, inEnd); 395 } 396 } 397 398 //根據 中序序列 和 後序|前序|層次序列 構建二叉樹。採用逐點插入法構建「二叉搜索樹」。 399 int cbiGetIndex(char inorder[],int n,char val) 400 {//獲取給定值在中序序列的下標 401 int i=0; 402 while(i<n && inorder[i]!=val) 403 { 404 i++; 405 } 406 return i; 407 } 408 void cbiBuildBST(BTREE &T,char inorder[],int n,char val) 409 {//插入一個值到二叉搜索樹 410 if(T==NULL) 411 { 412 T=(BTREE)malloc(sizeof(BTNode)); 413 T->data=val; 414 T->lchild=NULL; 415 T->rchild=NULL; 416 } 417 else if(cbiGetIndex(inorder,n,val) < cbiGetIndex(inorder,n,T->data)) 418 { 419 cbiBuildBST(T->lchild,inorder,n,val); 420 } 421 else 422 { 423 cbiBuildBST(T->rchild,inorder,n,val); 424 } 425 } 426 void createByInAndOtherOrder(BTREE &T,char input[],int isInputPostOrder,char inorder[],int n) 427 {//根據 中序序列 和 後序|前序|層次序列 構建二叉樹。採用逐點插入法構建「二叉搜索樹」。 428 printf("%s %d\n",input,n); 429 int i; 430 if(isInputPostOrder) 431 {//若input是後序序列，從後往前依次插入各元素 432 for(i=n-1;i>=0;i--) 433 { 434 cbiBuildBST(T,inorder,n,input[i]); 435 } 436 } 437 else{//不然input是前序或後序序列，從前日後依次插入各元素 438 for(i=0;i<n;i++) 439 { 440 cbiBuildBST(T,inorder,n,input[i]); 441 } 442 } 443 } 444 445 //二叉查找樹建立、查找、刪除（遞歸、非遞歸） 446 void insertBinarySearchTree_nonrecursive(BTREE &T,char item) 447 { 448 BTREE p,q; 449 p=(BTREE)malloc(sizeof(BTNode)); 450 p->data=item; 451 p->lchild=NULL; 452 p->rchild=NULL; 453 if(T==NULL) T=p; 454 else 455 { 456 q=T; 457 while(1) 458 { 459 if(item < q->data) 460 { 461 if(q->lchild!=NULL) q=q->lchild; 462 else 463 { 464 q->lchild=p; 465 break; 466 } 467 } 468 else 469 { 470 if(q->rchild!=NULL) q=q->rchild; 471 else 472 { 473 q->rchild=p; 474 break; 475 } 476 } 477 } 478 } 479 } 480 void insertBinarySearchTree_recursive(BTREE &T,char item) 481 { 482 if(T==NULL) 483 { 484 T=(BTREE)malloc(sizeof(BTNode)); 485 T->data=item; 486 T->lchild=NULL; 487 T->rchild=NULL; 488 } 489 else if(item< T->data) 490 { 491 insertBinarySearchTree_recursive(T->lchild,item); 492 } 493 else 494 { 495 insertBinarySearchTree_recursive(T->rchild,item); 496 } 497 } 498 499 BTREE searchBinarySearchTree_nonrecursive(BTREE T,char item) 500 { 501 if(T==NULL) 502 return NULL; 503 BTREE p=T; 504 while(p!=NULL) 505 { 506 if(p->data==item) 507 return p; 508 else if(p->data<item) 509 p=p->lchild; 510 else 511 p=p->rchild; 512 } 513 } 514 515 BTREE searchBinarySearchTree_recursive(BTREE T,char item) 516 { 517 if(T==NULL || T->data==item) 518 return T; 519 else if(T->data < item) 520 searchBinarySearchTree_recursive(T->lchild,item); 521 else 522 searchBinarySearchTree_recursive(T->rchild,item); 523 } 524 525 void deleteBSTNode(BTREE &T,char key) 526 {//刪除二叉查找樹中的一個節點。也能夠藉助後序非遞歸遍從來實現 ，此時棧頂元素存在的話爲當前節點的父節點 527 if(T==NULL)return; 528 else if(key<T->data)deleteBSTNode(T->lchild,key); 529 else if(key>T->data)deleteBSTNode(T->rchild,key); 530 else 531 { 532 if(T->lchild==NULL) 533 { 534 BTREE tmp=T; 535 T=T->rchild; 536 free(tmp); 537 } 538 else if(T->rchild==NULL) 539 { 540 BTREE tmp=T; 541 T=T->lchild; 542 free(tmp) ; 543 } 544 else 545 { 546 //找右子樹的最小節點（最左邊）的值替換被刪節點的值 547 BTREE p=T->rchild; 548 while(p->lchild!=NULL) 549 { 550 p=p->lchild; 551 } 552 T->data=p->data; 553 deleteBSTNode(T->rchild,p->data); 554 555 //也能夠找左子樹最右的值 556 // BTREE p=T->lchild; 557 // while(p->lchild!=NULL) 558 // { 559 // p=p->lchild; 560 // } 561 // T->data=p->data; 562 // deleteBSTNode(T->lchild,p->data); 563 } 564 } 565 } 566 567 void createBinarySearchTree(BTREE &T,char input[],int n) 568 { 569 int i; 570 for(i=0;i<n;i++) 571 { 572 insertBinarySearchTree_nonrecursive(T,input[i]); 573 // insertBinarySearchTree_recursive(T,input[i]); 574 } 575 576 for(i=0;i<n;i++) 577 {//驗證遞歸查找和非遞歸查找的正確性 578 if(searchBinarySearchTree_nonrecursive(T,input[i])!=searchBinarySearchTree_recursive(T,input[i])) 579 { 580 printf("error in searchBinarySearchTree\n"); 581 } 582 } 583 } 584 585 586 587 int main() 588 { 589 590 //測試1，特殊序列（表達式 ）。度爲1的節點空孩子必定要補空，度爲0的能夠不補；因爲表達式內部節點爲操做符度都爲故不須要補空 591 592 //度爲1的節點補空 593 //(*(+A(/(-BC)D))E) 594 //((A+((B-C)/D))*E) 595 //((A((BC-)D/)+)E*) 596 597 //度爲一、0的節點補空 598 //( *( +( A##) ( /( -( B##) ( C##) ) ( D##) ) ) ( E##) ) 599 //( ( ( #A#) +( ( ( #B#) -( #C#) ) /( #D#) ) ) *( #E#) ) 600 //(((##A)(((##B)(##C)-)(##D)/)+)(##E)*) 601 602 //測試2，普通序列 603 604 //度爲1的節點補空 605 //( A( BD( E( G#H )# ) )( CF# ) ) 606 //( ( DB( ( #GH )E# ) )A( FC# ) ) 607 //( ( D( ( #HG )#E )B )( F#C )A ) 608 609 //度爲一、0的節點補空 610 //( A( B( D##) ( E( G#( H##) ) #) ) ( C( F##) #) ) 611 //( ( ( #D#) B( ( #G( #H#) ) E#) ) A( ( #F#) C#) ) 612 //(((##D)((#(##H)G)#E)B)((##F)#C)A) 613 614 615 616 //測試1，特殊序列（表達式 ） ，度爲一、0的節點都得補空 617 //*+A##/-B##C##D##E## 618 //#A#+#B#-#C#/#D#*#E# 619 //##A##B##C-##D/+##E* 620 621 //測試2，普通序列 ，度爲一、0的節點都得補空 622 //ABD##EG#H###CF### 623 //#D#B#G#H#E#A#F#C# 624 //##D###HG#EB##F#CA 625 626 BTREE T=NULL; 627 628 //加括號：全補空或內補空，前綴、中綴、後綴 629 // char str[]="(*(+A(/(-BC)D))E)"; 630 //char str[]="( *(+(A##)(/(-(B##)(C##))(D##)))(E##) )"; 631 // char str[]="( A( BD( E( G#H )# ) )( CF# ) )"; 632 //char str[]="( A( B( D##) ( E( G#( H##) ) #) ) ( C( F##) #) )"; 633 // createPreOrder_withBrackets(str,T); 634 635 // char str[]="((A+((B-C)/D))*E)"; 636 // char str[]="( ( DB( ( #GH )E# ) )A( FC# ) )"; 637 //char str[]="( ( ( #A#) +( ( ( #B#) -( #C#) ) /( #D#) ) ) *( #E#) )"; 638 // createInOrder_withBrackets(str,T); 639 640 // char str[]="( ( A((BC-)D/)+ )E* )"; 641 //char str[]="(((##A)(((##B)(##C)-)(##D)/)+)(##E)*)"; 642 // char str[]="( ( D( ( #HG )#E )B )( F#C )A )"; 643 // createPostOrder_withBrackets(str,T); 644 645 646 //不加括號：全補空 ，前綴、後綴、廣度優先 647 // char str[]="*+A##/-B##C##D##E##"; 648 // char str[]="AB D## E G# H### C F## #"; 649 // createPreOrder(str,T); 650 651 // char str[]="#A#+#B#-#C#/#D#*#E#";//不帶括號的中序序列的樹是不惟一的，因此無法構建 652 // char str[]="#D#B#G#H#E#A#F#C#"; 653 // createInOrder(str,T); 654 655 // char str[]="##A##B##C-##D/+##E*"; 656 // char str[]="##D # ##H G#EB##F#CA"; 657 // createPostOrder(str,T); 658 659 // char layerSeq[]="12#34#####5"; 660 // createLayerOrder(layerSeq,sizeof(layerSeq)/sizeof(char)-1,T);//廣度優先、二叉樹形式補空 661 char layerSeq2[]="12#34###5"; 662 createLayerOrder2(layerSeq2,sizeof(layerSeq2)/sizeof(char)-1,T);//廣度優先、內補空 。能夠將序列轉換爲徹底二叉樹形式補空再用上述方法構建，也能夠在轉換過程當中構建。 663 664 //由前序、中序序列 或 後序、中序序列 或 中序、層次序列 構建二叉樹。不補空、不加括號。 665 char inorder[]="254163"; 666 char preorder[]="124536"; 667 char postorder[]="542631"; 668 char layerorder[]="123465"; 669 // createByInAndOtherOrder(T,postorder,1,inorder,sizeof(inorder)-1);//法1，三種輸入方式均可用此法構建二叉樹 670 // createByInAndOtherOrder(T,preorder,0,inorder,sizeof(inorder)-1); 671 // createByInAndOtherOrder(T,layerorder,0,inorder,sizeof(inorder)-1); 672 // createByPreInOrder(T,preorder,0,sizeof(preorder)-1-1,inorder,0,sizeof(inorder)-1-1) ;//法2，知道前序、中序 673 // createByPostInOrder(T,postorder,0,sizeof(postorder)-1-1,inorder,0,sizeof(inorder)-1-1);//法2，知道後序、中序 674 675 //二叉查找樹建立、查找（遞歸、非遞歸）、刪除 676 // char data[]="43265178"; 677 // createBinarySearchTree(T,data,sizeof(data)/sizeof(char)-1); 678 // deleteBSTNode(T,'4'); 679 680 681 682 searchPrefix(T); 683 printf("\n"); 684 searchInfix(T); 685 printf("\n"); 686 searchPostfix(T); 687 printf("\n"); 688 689 return 0; 690 }
遍歷
採用鏈式存儲：深度優先（前序、中序、後序）、廣度優先（層次）遍歷。（遞歸、非遞歸）
採用順序存儲：深度優先（前序、中序、後序）、廣度優先（層次）遍歷。（遞歸、非遞歸），輸入爲以徹底二叉樹補空的層次遍歷序列，所以遍歷方法與採用鏈式存儲的相同，只是改成藉助節點編號來反映節點間的父子關係。
複雜度：
深度優先：時間複雜度O(n)、空間複雜度O(h)
廣度優先：時間複雜度O(n)、空間複雜度O(n)
一、鏈式存儲的遍歷：（輸入的是樹的頭結點指針）
1）、遞歸遍歷：
前序、中序、後序遍歷（大同小異）：
1 void searchPrefix(BTREE T) 2 { 3 if(T!=NULL) 4 { 5 printf("%c",T->data); 6 7 searchPrefix(T->lchild); 8 9 searchPrefix(T->rchild); 10 } 11 }
能夠加以改進，以打印括號信息或補空信息。
1 void searchPrefix(BTREE T) 2 {//方式1補空：全部的空指針域用特殊字符替代 3 if(T!=NULL) 4 { 5 printf("%c",T->data); 6 7 searchPrefix(T->lchild); 8 9 searchPrefix(T->rchild); 10 } else 11 { 12 printf("#"); 13 } 14 } 15 16 void searchPrefix(BTREE T) 17 {//方式2補空：內部節點的空指針域用特殊字符替代 18 if(T!=NULL) 19 { 20 printf("%c",T->data); 21 22 searchPrefix(T->lchild); 23 if((T->lchild!=NULL || T->rchild!=NULL) && (T->lchild==NULL)){ printf("#"); }//內部節點的空孩子用特殊符號代替 24 25 searchPrefix(T->rchild); 26 if((T->lchild!=NULL || T->rchild!=NULL) && (T->rchild==NULL)){ printf("#"); }//內部節點的空孩子用特殊符號代替 27 } 28 } 29 30 void searchPrefix(BTREE T) 31 {//打印括號 32 if(T!=NULL) 33 { 34 if(T->lchild!=NULL || T->rchild!=NULL){ printf("( "); } 35 printf("%c",T->data); 36 37 searchPrefix(T->lchild); 38 39 searchPrefix(T->rchild); 40 if(T->lchild!=NULL || T->rchild!=NULL){ printf(" )"); } 41 } 42 }
層次遍歷：
1 #define M 100 2 void searchLayer(BTREE T) 3 {//廣度優先遞歸遍歷，與非遞歸遍歷幾乎同樣，非遞歸遍歷甚至更方便 4 static BTREE queue[M],p; 5 static int front=-1,rear=-1,isInitial=1; 6 if(T!=NULL) 7 { 8 if(isInitial) 9 { 10 queue[++rear]=T; 11 isInitial=0; 12 } 13 if(front<rear) 14 { 15 p=queue[++front]; 16 printf("%c",p->data); 17 if(p->lchild!=NULL)queue[++rear]=p->lchild; 18 if(p->rchild!=NULL)queue[++rear]=p->rchild; 19 searchLayer(T); 20 } 21 } 22 } 23 24 //也可藉助深度遍從來完成，如下是Java版，功能是輸出同層的節點 25 /** 26 * Definition for a binary tree node. 27 * public class TreeNode { 28 * int val; 29 * TreeNode left; 30 * TreeNode right; 31 * TreeNode(int x) { val = x; } 32 * } 33 */ 34 public class Solution { 35 public List<List<Integer>> levelOrder(TreeNode root) { 36 List<List<Integer>> res=new ArrayList<>(); 37 if(root==null) 38 { 39 return res; 40 } 41 helper(0,root,res); 42 return res; 43 } 44 public void helper(int depth,TreeNode node,List<List<Integer>>res) 45 {//經過 前序深度優先遍歷 來實現 遞歸版的廣度優先遍歷 46 if(node==null) return; 47 if(res.size()==depth) 48 { 49 res.add(new ArrayList<Integer>()); 50 } 51 res.get(depth).add(node.val); 52 helper(depth+1,node.left,res); 53 helper(depth+1,node.right,res); 54 } 55 }
2）、非遞歸遍歷：
前序、中序遍歷：
1 #define M 100 2 void preOrder(BTREE T) 3 { 4 BTREE stack[M],p=T; 5 int top=-1; 6 if(T!=NULL) 7 { 8 do 9 { 10 while(p!=NULL) 11 { 12 //visit(p); 13 printf("%c",p->data); 14 15 stack[++top]=p; 16 p=p->lchild; 17 } 18 p=stack[top--]; 19 p=p->rchild; 20 }while(!(p==NULL && top==-1)); 21 } 22 } 23 void inOrder(BTREE T) 24 { 25 BTREE stack[M],p=T; 26 int top=-1; 27 if(T!=NULL) 28 { 29 do 30 { 31 while(p!=NULL) 32 { 33 stack[++top]=p; 34 p=p->lchild; 35 } 36 p=stack[top--]; 37 38 //visit(p); 39 printf("%c",p->data); 40 41 42 p=p->rchild; 43 }while(!(p==NULL && top==-1)); 44 } 45 }
後序遍歷：（此遍歷在訪問節點時，棧中保存了根節點到當前節點的父節點的全部節點）
1 void postOrder(BTREE T) 2 {//後序非遞歸遍歷，在訪問節點時，棧裏保存了根到當前節點的全部節點 3 BTREE stack1[M],p=T; 4 int top=-1,flag,stack2[M];//flag用於標記節點是否能訪問 5 if(T!=NULL) 6 { 7 do 8 { 9 while(p!=NULL)//① 10 { 11 stack1[++top]=p; 12 stack2[top]=0; 13 p=p->lchild; 14 } 15 p=stack1[top]; 16 flag=stack2[top--]; 17 if(flag==0) 18 {//不能訪問 19 stack1[++top]=p; 20 stack2[top]=1; 21 p=p->rchild; 22 } 23 else 24 {//能訪問 25 //visit(p); 26 printf("%c",p->data); 27 28 p=NULL;//爲了跳過① 29 } 30 }while(!(p==NULL && top==-1)); 31 } 32 }
層次遍歷：
1 void layerOrder(BTREE T) 2 { 3 BTREE queue[M],p; 4 int front=-1,rear=-1; 5 if(T!=NULL) 6 { 7 queue[++rear]=T; 8 9 while(front<rear) 10 { 11 p=queue[++front]; 12 13 //visit(p); 14 printf("%c",p->data); 15 16 if(p->lchild!=NULL) 17 { 18 queue[++rear]=p->lchild; 19 } 20 if(p->rchild!=NULL) 21 { 22 queue[++rear]=p->rchild; 23 } 24 } 25 } 26 }
二、順序存儲遍歷：（輸入的是徹底二叉樹形式的 層次遍歷 序列，即除末層外，各層上的空節點都要用特殊字符填充；遍歷方式與鏈式存儲的非遞歸遍歷幾乎同樣，只是這裏用數組下標表示父子節點關係，而鏈式存儲中用到是指針）
1）遞歸遍歷：
前序、中序、後序、層次遍歷：
1 //bt爲輸入序列，補空爲徹底二叉樹形式 2 void searchPrefixOfArray(char bt[],int n,int i) 3 { 4 if(i<n && bt[i]!='#') 5 { 6 printf("%c",bt[i]); 7 searchPrefixOfArray(bt,n,2*i+1); 8 searchPrefixOfArray(bt,n,2*i+2); 9 } 10 } 11 void searchInfixOfArray(char bt[],int n,int i) 12 { 13 if(i<n && bt[i]!='#') 14 { 15 searchInfixOfArray(bt,n,2*i+1); 16 printf("%c",bt[i]); 17 searchInfixOfArray(bt,n,2*i+2); 18 } 19 } 20 void searchPostfixOfArray(char bt[],int n,int i) 21 { 22 if(i<n && bt[i]!='#') 23 { 24 searchPostfixOfArray(bt,n,2*i+1); 25 searchPostfixOfArray(bt,n,2*i+2); 26 printf("%c",bt[i]); 27 } 28 } 29 void searchLayerOfArray(char bt[],int n,int i) 30 { 31 while(i<n) 32 { 33 if(bt[i]!='#') 34 { 35 printf("%c",bt[i]); 36 } 37 i++; 38 } 39 }
2）非遞歸遍歷：
前序、中序遍歷：
1 void preOrderOfArray(char bt[],int n) 2 {//輸入序列按徹底二叉樹形式補空 3 int stack[M],top=-1,i=0; 4 if(n>0) 5 { 6 do 7 { 8 while(i<n && bt[i]!='#') 9 { 10 //visio(bt[i]); 11 printf("%c",bt[i]); 12 13 stack[++top]=i; 14 i=2*i+1; 15 } 16 i=stack[top--]; 17 i=2*i+2; 18 }while(!((i>=n || bt[i]=='#') && top==-1)); 19 } 20 } 21 22 void inOrderOfArray(char bt[],int n) 23 {//輸入序列按徹底二叉樹形式補空 24 int stack[M],top=-1,i=0; 25 if(n>0) 26 { 27 do 28 { 29 while(i<n && bt[i]!='#') 30 { 31 stack[++top]=i; 32 i=2*i+1; 33 } 34 i=stack[top--]; 35 36 //visio(bt[i]); 37 printf("%c",bt[i]); 38 39 i=2*i+2; 40 }while(!((i>=n || bt[i]=='#') && top==-1)); 41 } 42 }
後序遍歷：
1 void postOrderOfArray(char bt[],int n) 2 {//輸入序列按徹底二叉樹形式補空 3 int stack1[M],stack2[M],top=-1,i=0,flag; 4 if(n>0) 5 { 6 do 7 { 8 while(i<n && bt[i]!='#') 9 { 10 stack1[++top]=i; 11 stack2[top]=0; 12 i=2*i+1; 13 } 14 i=stack1[top]; 15 flag=stack2[top--]; 16 17 if(flag==0) 18 { 19 stack1[++top]=i; 20 stack2[top]=1; 21 i=2*i+2; 22 } 23 else 24 { 25 //visit(bt[i]); 26 printf("%c",bt[i]); 27 28 i=n; 29 } 30 }while(!((i>=n || bt[i]=='#') && top==-1)); 31 } 32 }
層次遍歷：
1 void layerOrderOfArray(char bt[],int n) 2 {//輸入序列按徹底二叉樹形式補空 3 int queue[M],front=-1,rear=-1,i; 4 if(n>0) 5 { 6 queue[++rear]=0; 7 while(front<rear) 8 { 9 i=queue[++front]; 10 11 //visit(bt[i]); 12 printf("%c",bt[i]); 13 14 if(2*i+1<n && bt[2*i+1]!='#') queue[++rear]=2*i+1; 15 if(2*i+2<n && bt[2*i+2]!='#') queue[++rear]=2*i+2; 16 } 17 } 18 }
附：上述遍歷的完整代碼：
1 #include<stdio.h> 2 #include<malloc.h> 3 typedef struct node 4 { 5 int data; 6 struct node* lchild; 7 struct node* rchild; 8 }BTNode,*BTREE; 9 10 //鏈式存儲遞歸遍歷（深度優先、廣度優先） 11 void searchPrefix(BTREE T) 12 { 13 if(T!=NULL) 14 { 15 printf("%c",T->data); 16 17 searchPrefix(T->lchild); 18 19 searchPrefix(T->rchild); 20 } 21 } 22 void searchInfix(BTREE T) 23 { 24 if(T!=NULL) 25 { 26 searchInfix(T->lchild); 27 28 printf("%c",T->data); 29 30 searchInfix(T->rchild); 31 } 32 } 33 void searchPostfix(BTREE T) 34 { 35 if(T!=NULL) 36 { 37 searchPostfix(T->lchild); 38 39 searchPostfix(T->rchild); 40 41 printf("%c",T->data); 42 } 43 } 44 45 #define M 100 46 void searchLayer(BTREE T) 47 {//廣度優先遞歸遍歷，也可藉助深度遍從來完成 48 static BTREE queue[M],p; 49 static int front=-1,rear=-1,isInitial=1; 50 if(T!=NULL) 51 { 52 if(isInitial) 53 { 54 queue[++rear]=T; 55 isInitial=0; 56 } 57 if(front<rear) 58 { 59 p=queue[++front]; 60 printf("%c",p->data); 61 if(p->lchild!=NULL)queue[++rear]=p->lchild; 62 if(p->rchild!=NULL)queue[++rear]=p->rchild; 63 searchLayer(T); 64 } 65 } 66 } 67 68 //鏈式存儲非遞歸遍歷（深度優先、廣度優先） 69 void preOrder(BTREE T) 70 { 71 BTREE stack[M],p=T; 72 int top=-1; 73 if(T!=NULL) 74 { 75 do 76 { 77 while(p!=NULL) 78 { 79 //visit(p); 80 printf("%c",p->data); 81 82 stack[++top]=p; 83 p=p->lchild; 84 } 85 p=stack[top--]; 86 p=p->rchild; 87 }while(!(p==NULL && top==-1)); 88 } 89 } 90 void inOrder(BTREE T) 91 { 92 BTREE stack[M],p=T; 93 int top=-1; 94 if(T!=NULL) 95 { 96 do 97 { 98 while(p!=NULL) 99 { 100 stack[++top]=p; 101 p=p->lchild; 102 } 103 p=stack[top--]; 104 105 //visit(p); 106 printf("%c",p->data); 107 108 109 p=p->rchild; 110 }while(!(p==NULL && top==-1)); 111 } 112 } 113 void postOrder(BTREE T) 114 {//後序非遞歸遍歷，在訪問節點時，棧裏保存了根到當前節點父節點的全部節點 115 BTREE stack1[M],p=T; 116 int top=-1,flag,stack2[M];//flag用於標記節點是否能訪問 117 if(T!=NULL) 118 { 119 do 120 { 121 while(p!=NULL)//① 122 { 123 stack1[++top]=p; 124 stack2[top]=0; 125 p=p->lchild; 126 } 127 p=stack1[top]; 128 flag=stack2[top--]; 129 if(flag==0) 130 {//不能訪問 131 stack1[++top]=p; 132 stack2[top]=1; 133 p=p->rchild; 134 } 135 else 136 {//能訪問 137 //visit(p); 138 printf("%c",p->data); 139 140 p=NULL;//爲了跳過① 141 } 142 }while(!(p==NULL && top==-1)); 143 } 144 } 145 146 void layerOrder(BTREE T) 147 { 148 BTREE queue[M],p; 149 int front=-1,rear=-1; 150 if(T!=NULL) 151 { 152 queue[++rear]=T; 153 154 while(front<rear) 155 { 156 p=queue[++front]; 157 158 //visit(p); 159 printf("%c",p->data); 160 161 if(p->lchild!=NULL) 162 { 163 queue[++rear]=p->lchild; 164 } 165 if(p->rchild!=NULL) 166 { 167 queue[++rear]=p->rchild; 168 } 169 } 170 } 171 } 172 173 //順序存儲遞歸遍歷（深度優先、廣度優先） 174 void searchPrefixOfArray(char bt[],int n,int i) 175 { 176 if(i<n && bt[i]!='#') 177 { 178 printf("%c",bt[i]); 179 searchPrefixOfArray(bt,n,2*i+1); 180 searchPrefixOfArray(bt,n,2*i+2); 181 } 182 } 183 void searchInfixOfArray(char bt[],int n,int i) 184 { 185 if(i<n && bt[i]!='#') 186 { 187 searchInfixOfArray(bt,n,2*i+1); 188 printf("%c",bt[i]); 189 searchInfixOfArray(bt,n,2*i+2); 190 } 191 } 192 void searchPostfixOfArray(char bt[],int n,int i) 193 { 194 if(i<n && bt[i]!='#') 195 { 196 searchPostfixOfArray(bt,n,2*i+1); 197 searchPostfixOfArray(bt,n,2*i+2); 198 printf("%c",bt[i]); 199 } 200 } 201 void searchLayerOfArray(char bt[],int n,int i) 202 { 203 while(i<n) 204 { 205 if(bt[i]!='#') 206 { 207 printf("%c",bt[i]); 208 } 209 i++; 210 } 211 } 212 213 //順序存儲非遞歸遍歷（深度優先、廣度優先） 214 void preOrderOfArray(char bt[],int n) 215 {//輸入序列按徹底二叉樹形式補空 216 int stack[M],top=-1,i=0; 217 if(n>0) 218 { 219 do 220 { 221 while(i<n && bt[i]!='#') 222 { 223 //visio(bt[i]); 224 printf("%c",bt[i]); 225 226 stack[++top]=i; 227 i=2*i+1; 228 } 229 i=stack[top--]; 230 i=2*i+2; 231 }while(!((i>=n || bt[i]=='#') && top==-1)); 232 } 233 } 234 235 void inOrderOfArray(char bt[],int n) 236 {//輸入序列按徹底二叉樹形式補空 237 int stack[M],top=-1,i=0; 238 if(n>0) 239 { 240 do 241 { 242 while(i<n && bt[i]!='#') 243 { 244 stack[++top]=i; 245 i=2*i+1; 246 } 247 i=stack[top--]; 248 249 //visio(bt[i]); 250 printf("%c",bt[i]); 251 252 i=2*i+2; 253 }while(!((i>=n || bt[i]=='#') && top==-1)); 254 } 255 } 256 257 void postOrderOfArray(char bt[],int n) 258 {//輸入序列按徹底二叉樹形式補空 259 int stack1[M],stack2[M],top=-1,i=0,flag; 260 if(n>0) 261 { 262 do 263 { 264 while(i<n && bt[i]!='#') 265 { 266 stack1[++top]=i; 267 stack2[top]=0; 268 i=2*i+1; 269 } 270 i=stack1[top]; 271 flag=stack2[top--]; 272 273 if(flag==0) 274 { 275 stack1[++top]=i; 276 stack2[top]=1; 277 i=2*i+2; 278 } 279 else 280 { 281 //visit(bt[i]); 282 printf("%c",bt[i]); 283 284 i=n; 285 } 286 }while(!((i>=n || bt[i]=='#') && top==-1)); 287 } 288 } 289 290 void layerOrderOfArray(char bt[],int n) 291 {//輸入序列按徹底二叉樹形式補空 292 int queue[M],front=-1,rear=-1,i; 293 if(n>0) 294 { 295 queue[++rear]=0; 296 while(front<rear) 297 { 298 i=queue[++front]; 299 300 //visit(bt[i]); 301 printf("%c",bt[i]); 302 303 if(2*i+1<n && bt[2*i+1]!='#') queue[++rear]=2*i+1; 304 if(2*i+2<n && bt[2*i+2]!='#') queue[++rear]=2*i+2; 305 } 306 } 307 } 308 309 310 //構建 311 char nextToken(char str[]) //讀取下一字符，略過空格 312 { 313 static int pos=0; 314 while(str[pos]!='\0' && str[pos]==' '){ pos++; } 315 return str[pos++]; 316 } 317 318 319 void createPreOrder(char prefixStr[],BTREE *T) 320 {//輸入序列爲 全補空、不帶括號 的序列 321 char x=nextToken(prefixStr); 322 if(x=='#') 323 { 324 *T=NULL; 325 } 326 else 327 { 328 *T=(BTREE)malloc(sizeof(BTNode)); 329 (*T)->data=x; 330 createPreOrder(prefixStr,&((*T)->lchild)); 331 createPreOrder(prefixStr,&((*T)->rchild)); 332 } 333 } 334 335 int main() 336 { 337 338 //一、鏈式存儲遍歷 339 BTREE T=NULL; 340 //char str[]="*+A##/-B##C##D##E##"; 341 char str[]="AB D## E G# H### C F## #"; 342 createPreOrder(str,&T); 343 344 //1.一、鏈式存儲遞歸遍歷 345 printf("鏈式存儲遞歸遍歷：\n"); 346 searchPrefix(T); 347 printf("\n"); 348 349 searchInfix(T); 350 printf("\n"); 351 352 searchPostfix(T); 353 printf("\n"); 354 355 searchLayer(T); 356 printf("\n"); 357 358 //1.二、鏈式存儲非遞歸遍歷 359 printf("\n鏈式存儲非遞歸遍歷：\n"); 360 preOrder(T); 361 printf("\n"); 362 363 inOrder(T); 364 printf("\n"); 365 366 postOrder(T); 367 printf("\n"); 368 369 layerOrder(T); 370 printf("\n"); 371 372 //二、順序存儲遍歷 373 char input[]="abcd#f#####e"; 374 int n=sizeof(input)-1; 375 376 //2.一、順序存儲遞歸遍歷 377 printf("\n順序存儲遞歸遍歷：%d\n",n); 378 searchPrefixOfArray(input,n,0); 379 printf("\n"); 380 381 searchInfixOfArray(input,n,0); 382 printf("\n"); 383 384 searchPostfixOfArray(input,n,0); 385 printf("\n"); 386 387 searchLayerOfArray(input,n,0); 388 printf("\n"); 389 390 //2.二、順序存儲非遞歸遍歷 391 printf("\n順序存儲非遞歸遍歷：%d\n",n); 392 preOrderOfArray(input,n); 393 printf("\n"); 394 395 inOrderOfArray(input,n); 396 printf("\n"); 397 398 postOrderOfArray(input,n); 399 printf("\n"); 400 401 layerOrderOfArray(input,n); 402 printf("\n"); 403 404 return 0; 405 }
銷燬
經過遍從來銷燬：後序遞歸遍歷；後序非遞歸遍歷（此時棧中保存了當前節點的雙親節點到根節點的全部節點）
特殊二叉樹
一、理想平衡二叉樹（只有最後一層可能不滿）
滿二叉樹（是理想平衡二叉樹，且各層都滿）
徹底二叉樹（是理想平衡二叉樹，且最後一層節點依次從左填到右）
二、正則（正規）二叉樹：只有度爲0或2的節點的二叉樹
三、線索二叉樹：將二叉樹的空指針域用來存儲直接前驅、直接後繼節點（稱爲線索）的二叉樹，這樣遍歷就不須要用棧了。
經過遍歷二叉樹進行二叉樹的線索化，根據遍歷方法的不一樣分爲前序線索二叉樹、中序線索二叉樹、後序線索二叉樹
前序線索二叉樹中不能找到某些節點的直接前驅節點、後序線索二叉樹不能找到某些二叉樹的直接後繼節點，所以一般用中序線索二叉樹。
四、哈夫曼樹（最優二叉樹）：帶權路徑長度WPL最小的二叉樹。
WPL=Σ（葉節點權值×路徑長度）= 非根節點的權值和 = 非葉節點的權值和
沒有度爲1的節點（即哈夫曼樹是正則二叉樹）、給定權值序列構造的哈夫曼樹不惟一但WPL相同。
五、二叉查找樹（亦稱二叉排序樹、二叉搜索樹）BST：每一個節點的左子樹的全部節點的值小於該節點值，右子樹的全部節點值小於該節點值的二叉樹。
查找長度：
內部節點、外部節點、平均查找長度ASL（成功時ASL一、失敗時ASL二、綜合）、內路徑長度IPL、外路徑長度EPL。EPL=IPL+2n，
某個節點查找成功時比較次數=所在層數=路徑+1，故全部節點查找成功的比較次數=IPL+n；某個值查找失敗的比較次數=最後一次比較的葉節點的層=外部節點的外路徑長度，故全部節點查找失敗的比較次數爲EPL
ASL1=(IPL+n)/n，ASL2=EPL/(n+1)
ASL=(IPL+n+EPL)/(n+n+1)=(3n+IPL)/(2n+1)，當IPL最小時平均查找長度最小。
種數：對包含n個數的有序序列，其BST樹有卡特蘭數種。
二叉查找樹的中序遍歷獲得升序序列，判斷二叉樹是不是二叉查找樹能夠看中序遍歷序列是否升序來斷定（遞歸、非遞歸都可），固然，還有其餘更好的方法。
1）二叉查找樹建立（遞歸、非遞歸）：（只給定BST的前序序列便可構建出BST，依次從前日後插入每一個元素便可；只給定後序序列時相似，只不過是從後徹底插入）
1 void insertBinarySearchTree_nonrecursive(BTREE &T,char item) 2 { 3 BTREE p,q; 4 p=(BTREE)malloc(sizeof(BTNode)); 5 p->data=item; 6 p->lchild=NULL; 7 p->rchild=NULL; 8 if(T==NULL) T=p; 9 else 10 { 11 q=T; 12 while(1) 13 { 14 if(item < q->data) 15 { 16 if(q->lchild!=NULL) q=q->lchild; 17 else 18 { 19 q->lchild=p; 20 break; 21 } 22 } 23 else 24 { 25 if(q->rchild!=NULL) q=q->rchild; 26 else 27 { 28 q->rchild=p; 29 break; 30 } 31 } 32 } 33 } 34 } 35 void insertBinarySearchTree_recursive(BTREE &T,char item) 36 { 37 if(T==NULL) 38 { 39 T=(BTREE)malloc(sizeof(BTNode)); 40 T->data=item; 41 T->lchild=NULL; 42 T->rchild=NULL; 43 } 44 else if(item< T->data) 45 { 46 insertBinarySearchTree_recursive(T->lchild,item); 47 } 48 else 49 { 50 insertBinarySearchTree_recursive(T->rchild,item); 51 } 52 } 53 void createBinarySearchTree(BTREE &T,char input[],int n) 54 { 55 int i; 56 for(i=0;i<n;i++) 57 { 58 // insertBinarySearchTree_nonrecursive(T,input[i]); 59 insertBinarySearchTree_recursive(T,input[i]); 60 } 61 }
2）二叉查找樹查找節點（遞歸、非遞歸）：
1 BTREE searchBinarySearchTree_nonrecursive(BTREE T,char item) 2 { 3 BTREE p=T; 4 while(p!=NULL) 5 { 6 if(p->data==item) 7 return p; 8 else if(p->data<item) 9 p=p->lchild; 10 else 11 p=p->rchild; 12 } 13 return p; 14 } 15 16 BTREE searchBinarySearchTree_recursive(BTREE T,char item) 17 { 18 if(T==NULL || T->data==item) 19 return T; 20 else if(T->data < item) 21 searchBinarySearchTree_recursive(T->lchild,item); 22 else 23 searchBinarySearchTree_recursive(T->rchild,item); 24 }
3）二叉查找樹刪除節點（刪除後維護BST的性質，BST形狀可能不惟一）：相關：LeetCode450
先找到節點，若找到，則進行刪除操做：
a、如果葉子節點則直接刪除；
b、不然，若左孩子空、右孩子非空，則刪掉後用右孩子代替之；
c、不然，若左孩子非空、右孩子空，則刪掉後用左孩子替代之；
d、不然，值用右子樹的最小節點（即右子樹的最左節點）的值代替之，並維護右子樹即：對該最左節點進行a或b操做。固然，也能夠用左子樹的最大節點（即左子樹的最右節點）的值代替之並對該最右節點進行a或c操做。
遞歸法：
1 void deleteBSTNode(BTREE &T,char key) 2 {//刪除二叉查找樹中的一個節點。也能夠藉助後序非遞歸遍從來實現 ，此時棧頂元素存在的話爲當前節點的父節點 3 if(T==NULL)return; 4 else if(key<T->data)deleteBSTNode(T->lchild,key); 5 else if(key>T->data)deleteBSTNode(T->rchild,key); 6 else 7 { 8 if(T->lchild==NULL) 9 { 10 BTREE tmp=T; 11 T=T->rchild; 12 free(tmp); 13 } 14 else if(T->rchild==NULL) 15 { 16 BTREE tmp=T; 17 T=T->lchild; 18 free(tmp) ; 19 } 20 else 21 { 22 //找右子樹的最小節點（最左邊）的值替換被刪節點的值 23 BTREE p=T->rchild; 24 while(p->lchild!=NULL) 25 { 26 p=p->lchild; 27 } 28 T->data=p->data; 29 deleteBSTNode(T->rchild,p->data); 30 31 //也能夠找左子樹最右的值 32 // BTREE p=T->lchild; 33 // while(p->rchild!=NULL) 34 // { 35 // p=p->rchild; 36 // } 37 // T->data=p->data; 38 // deleteBSTNode(T->lchild,p->data); 39 } 40 } 41 }
非遞歸法：（用後序非遞歸遍歷，比較麻煩）
4）驗證是不是二叉查找樹：二叉查找樹的中序遍歷獲得升序序列，判斷二叉樹是不是二叉查找樹能夠看中序遍歷序列是否升序來斷定（遞歸、非遞歸都可），固然，還有其餘更好的方法，查看相關--LeetCode98。
1 /** 2 * Definition for a binary tree node. 3 * public class TreeNode { 4 * int val; 5 * TreeNode left; 6 * TreeNode right; 7 * TreeNode(int x) { val = x; } 8 * } 9 */ 10 public class Solution {//經過中序遍歷。是BST 等價於 中序遍歷序列是升序 11 public boolean isValidBST(TreeNode root) { 12 inOrder(root); 13 return isValid; 14 } 15 private TreeNode lastVisited=null; 16 private boolean isValid=true; 17 private void inOrder(TreeNode root) 18 {//中序遍歷，若是遇到上次訪問節點值比當前根節點大，則invalid並結束 19 if(root!=null) 20 { 21 inOrder(root.left); 22 23 if(lastVisited!=null) 24 { 25 if(lastVisited.val>=root.val) 26 { 27 isValid=false; 28 } 29 } 30 lastVisited=root; 31 32 inOrder(root.right); 33 } 34 } 35 } 36 37 public class Solution { 38 public boolean isValidBST(TreeNode root) { 39 return isBST(root, Long.MIN_VALUE, Long.MAX_VALUE); 40 } 41 42 private boolean isBST(TreeNode root, long min, long max) {//經過前序遍歷 43 44 if(root == null) { 45 return true; 46 } 47 48 // check the node's restriction 49 if(!(root.val > min && root.val < max)) { 50 return false; 51 } 52 53 // check left 54 boolean l = isBST(root.left, min, root.val); 55 boolean r = isBST(root.right, root.val, max); 56 57 return (l == true && r == true); 58 } 59 }
最優二叉查找樹：給定一個有序序列{xi}，i∈[1,n]，再給定查找每一個序列值的機率bi以及查找值不存在時落入區間(xi, xi+1)，i∈[0,n]的機率ai，全部的ai、bi總和爲1。如何構建二叉搜索樹使平均查找路徑最短？——動態規劃（與求矩陣連乘的最少乘法次數很像）
二叉查找樹的平衡：普通的二叉查找樹雖然平均時間複雜度爲O(lgn)，但最壞狀況下退化爲線性鏈表此時時間複雜度爲O(n)，所以實際應用中不實用。一般考慮平衡性，如：
5.一、平衡二叉樹（亦稱平衡二叉查找樹、AVL樹）：每一個節點的左右子樹深度最多差1的二叉查找樹
注意，平衡二叉樹最先是爲了改進二叉排序樹的性能而考慮平衡性進而提出來的——即AVL樹（固然，其平衡性沒有理想平衡二叉樹要求那麼嚴，不然維護成本過高），因此通常說到平衡二叉樹指的是平衡的二叉排序樹。
最小平衡二叉樹：節點數最少時的平衡二叉樹，此時每一個分支節點的左右子樹深度都剛好相差1。設高爲h的最小平衡二叉樹的節點總數爲F(h)，則F(h)=左子樹節點總數+右子樹節點總數+1，即F(h)=F(h-1)+F(h-2)+1，F(1)=一、F(2)=2。
5.二、紅黑樹：是另外一種考慮了平衡性了的二叉查找樹。（可參閱: 紅黑樹原理和算法）
性質：
一、每一個節點爲紅色或黑色；
二、根節點爲黑色；
三、葉節點爲黑色（此葉節點指爲空NULL的葉節點）；
四、紅色節點的子節點必定是黑色；
五、一個節點到它每一個同層子孫節點的路徑上黑色節點數相同（此條保證了沒有一條路徑會比其餘路徑長2倍，故紅黑樹是相對平衡的BST）。
含有n個節點的紅黑樹高度最多爲 2*ceil( log2(n+1) )，即高爲h的紅黑樹其節點數至少有2h/2-1個，所以最壞時間複雜度爲O(lgn)。
複雜度：插入、刪除、查找的平均和最壞時間複雜度爲O(lgn)，效率高。插入、刪除節點可能會破壞上述性質，所以須要進行左旋或右旋轉操做以維護性質。因爲紅黑樹平衡性要求沒有平衡二叉樹那麼高，所以插入或刪除節點的維護代價比後者低。
應用：主要用來存儲有序數據，如Java中的TreeMap、TreeSet，C++中STL中的map、set，Linux中的內存管理等就用了紅黑樹實現。
5.三、B、B+樹：它們不是二叉樹查找樹，但由二叉查找樹擴展而來，是多叉的查找樹，且增長了一些有利於平衡性的限制。基於內存的B+樹實現：
1 package buaa.act.ucar.imtg.index.node.temporal; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 6 import buaa.act.ucar.util.config.ConfigFileParser; 7 8 /** 9 * The implementation of B+-Tree based on the implementation in reference <a>http://en.wikipedia.org/wiki/B%2B_tree</a><br> 10 * <br> 11 * 一個節點的某個key＞左孩子節點內全部的key且≤右孩子節點內全部的key。等號只有對於葉節點的父節點成立，也即B+tree的內部節點的key都不一樣。 <br> 12 * <br> 13 * 若插入後節點的鍵的數量超出上閾值1時即進行分裂，一個節點分裂成兩個後，對於葉節點來講後節點的第一個元素的鍵做爲新鍵複製到父節點、對於內部節點來講後節點的第一個元素的鍵移到父節點。<br> 14 * 刪除時如有節點合併則合併過程與上述過程相反。<br> 15 * <br> 16 * <br> 17 * note: 啓用插入借位（或稱旋轉）能減小內存佔用。然而：<br> 18 * 對於隨機寫入來講，不採用插入借位會提升查詢性能，由於每一個節點的數據量少了，能減小比較；<br> 19 * 對於升序插入來講，啓用插入借位老是能提升插入、查詢、刪除性能，對於升序輸入來講，採用size-1:1的分裂方法能進一步提升性能。 20 * 21 * 22 * @author zsm 23 * 24 * @param <K> 25 * @param <V> 26 */ 27 public class BPlusTree<K extends Comparable<K>, V> { 28 29 /** 30 * 樹的分支<br> 31 * a) 非根內部節點的孩子數： [ Math.ceil(factor/2), factor ]<br/> 32 * b) 葉子節點的孩子數： [ Math.ceil(factor/2)-1, factor-1 ] 33 */ 34 private int factor; 35 36 private static final int DEFAULT_FACTOR = 5; 37 38 private int MIN_CHILDREN_FOR_INTERNAL; 39 private int MAX_CHILDREN_FOR_INTERNAL; 40 private int MIN_CHILDREN_FOR_LEAF; 41 private int MAX_CHILDREN_FOR_LEAF; 42 43 // 給插入時用 44 private Object[] tmpNewKeys; 45 private Node[] tmpNewPointers; 46 private Object[] tmpNewValues; 47 48 private Node<K, V> root; 49 50 /** 葉節點數據記錄總數 */ 51 private int dataCount; 52 53 /** 54 * 待存數據是否有序存入 ，決定了節點的分裂方案：<br> 55 * ASCENDING：分裂後新節點存一個元素 <br> 56 * DESCENDING：分裂後原節點存一個元素<br> 57 * RANDOM：對半分 58 */ 59 public enum InputDataOrder { 60 ASCENDING, DESCENDING, RANDOM 61 } 62 63 private InputDataOrder inputDataOrder; 64 65 public BPlusTree(InputDataOrder inputDataOrder) { 66 this(DEFAULT_FACTOR, inputDataOrder); 67 } 68 69 public BPlusTree(int factor, InputDataOrder inputDataOrder) { 70 if (factor < 3) { 71 System.out.print("order must be greater than 2"); 72 System.exit(0); 73 } 74 75 // System.out.println("factor for tree:" + factor); 76 this.inputDataOrder = inputDataOrder; 77 78 this.factor = factor; 79 80 this.MIN_CHILDREN_FOR_INTERNAL = (this.factor + 1) / 2; 81 this.MAX_CHILDREN_FOR_INTERNAL = this.factor; 82 this.MIN_CHILDREN_FOR_LEAF = this.MIN_CHILDREN_FOR_INTERNAL - 1; 83 this.MAX_CHILDREN_FOR_LEAF = this.MAX_CHILDREN_FOR_INTERNAL - 1; 84 85 // 比容許的最大值多1 86 tmpNewKeys = new Object[MAX_CHILDREN_FOR_INTERNAL]; 87 tmpNewPointers = new Node[MAX_CHILDREN_FOR_INTERNAL + 1]; 88 tmpNewValues = new Object[MAX_CHILDREN_FOR_LEAF + 1]; 89 90 this.root = new LeafNode<K, V>(); 91 this.dataCount = 0; 92 } 93 94 /** 95 * 根據給定的key獲取對應的值 96 */ 97 public V get(K key) { 98 return this.root.get(key); 99 } 100 101 /** 102 * 獲取指定key範圍內的值 103 */ 104 public ArrayList<V> get(K keyStart, K keyEnd) { 105 if (keyStart.compareTo(keyEnd) > 0) { 106 return null; 107 } 108 LeafNode<K, V> leafNodeStart, leafNodeEnd; 109 if (root instanceof LeafNode) {// 說明整個樹只有一個節點 110 leafNodeStart = leafNodeEnd = (LeafNode<K, V>) root; 111 } else { 112 leafNodeStart = ((InternalNode<K, V>) root).getLeafNodeByKey(keyStart); 113 leafNodeEnd = ((InternalNode<K, V>) root).getLeafNodeByKey(keyEnd); 114 } 115 116 // 獲取結果 117 ArrayList<V> res = new ArrayList<>(); 118 int nodeSize; 119 K tmpK; 120 do { 121 nodeSize = leafNodeStart.size; 122 for (int i = 0; i < nodeSize; i++) { 123 tmpK = (K) leafNodeStart.keys[i]; 124 if (keyStart.compareTo(tmpK) <= 0 && tmpK.compareTo(keyEnd) <= 0) { 125 res.add((V) leafNodeStart.values[i]); 126 } 127 } 128 leafNodeStart = (LeafNode<K, V>) leafNodeStart.next; 129 } while (leafNodeStart != leafNodeEnd.next); 130 return res; 131 } 132 133 /** 134 * 獲取指定oid在指定key範圍內的值，此方法在B+tree key 爲gpstime#oid組合的String類型時 才適用 135 */ 136 public ArrayList<V> get(String oid, K keyStart, K keyEnd) { 137 if (keyStart.compareTo(keyEnd) > 0) { 138 return null; 139 } 140 LeafNode<K, V> leafNodeStart, leafNodeEnd; 141 if (root instanceof LeafNode) {// 說明整個樹只有一個節點 142 leafNodeStart = leafNodeEnd = (LeafNode<K, V>) root; 143 } else { 144 leafNodeStart = ((InternalNode<K, V>) root).getLeafNodeByKey(keyStart); 145 leafNodeEnd = ((InternalNode<K, V>) root).getLeafNodeByKey(keyEnd); 146 } 147 148 // 獲取結果 149 ArrayList<V> res = new ArrayList<>(); 150 int nodeSize; 151 K tmpK; 152 String tmpOid; 153 do { 154 nodeSize = leafNodeStart.size; 155 for (int i = 0; i < nodeSize; i++) { 156 tmpK = (K) leafNodeStart.keys[i]; 157 tmpOid = tmpK.toString(); 158 // System.out.println("_" + tmpOid); 159 tmpOid = tmpOid.substring(tmpOid.indexOf(ConfigFileParser.bplustree_TagForDivdingGpstimeDevsn) + 1);// 獲取oid 160 if (tmpOid.equals(oid) && keyStart.compareTo(tmpK) <= 0 && tmpK.compareTo(keyEnd) <= 0) { 161 res.add((V) leafNodeStart.values[i]); 162 } 163 } 164 leafNodeStart = (LeafNode<K, V>) leafNodeStart.next; 165 } while (leafNodeStart != leafNodeEnd.next); 166 return res; 167 } 168 169 /** 170 * 插入鍵值對，若鍵已存在，則更新值 171 */ 172 public void set(K key, V value) { 173 if (key == null) 174 throw new NullPointerException("key must not be null."); 175 176 Node<K, V> node = this.root.insert(key, value); 177 if (node != null) 178 this.root = node; 179 } 180 181 /** 182 * 刪除給定的key對應的值 183 */ 184 public void remove(K key) { 185 // TODO Auto-generated method stub 186 Node node = this.root.remove(key); 187 if (node != null) { 188 this.root = node; 189 } 190 } 191 192 /** 獲取樹的根節點 */ 193 public Node<K, V> getRoot() { 194 return this.root; 195 } 196 197 /** 獲取最左邊的葉節點 */ 198 public LeafNode<K, V> getLeftestLeafNode() { 199 Node<K, V> node = this.root; 200 while (!(node instanceof LeafNode)) { 201 node = ((InternalNode<K, V>) node).pointers[0]; 202 } 203 return (LeafNode<K, V>) node; 204 } 205 206 /** 獲取樹中數據記錄總數 */ 207 public int getDataCount() { 208 return this.dataCount; 209 } 210 211 /** 212 * 獲取全部value 213 */ 214 public List<V> getAllValues() { 215 List<V> res = new ArrayList<>(this.dataCount); 216 LeafNode<K, V> leafNode = getLeftestLeafNode(); 217 while (leafNode != null) { 218 for (int i = 0; i < leafNode.size; i++) { 219 res.add((V) leafNode.values[i]); 220 } 221 leafNode = (LeafNode<K, V>) leafNode.next; 222 } 223 return res; 224 } 225 226 /** 獲取樹的高度，最少爲1 */ 227 public int getHeight() { 228 int height = 1; 229 Node<K, V> node = this.root; 230 while (!(node instanceof LeafNode)) { 231 node = ((InternalNode<K, V>) node).pointers[0]; 232 height++; 233 } 234 return height; 235 } 236 237 /** 打印樹結構 */ 238 public void printTree() { 239 this.printTreeFrom(this.root); 240 } 241 242 private void printTreeFrom(Node<K, V> startRoot) { 243 System.out.println("print tree:"); 244 Node<K, V> curNode = null; 245 do { 246 curNode = startRoot; 247 while (curNode != null) { 248 // System.out.print("|"); 249 // for (int i = 0; i < curNode.size; i++) { 250 // System.out.print(curNode.keys[i]); 251 // if (i != curNode.size - 1) { 252 // System.out.print(","); 253 // } 254 // } 255 // System.out.print("| "); 256 System.out.print(curNode); 257 curNode = curNode.next; 258 } 259 if (startRoot instanceof InternalNode) { 260 startRoot = ((InternalNode) startRoot).pointers[0]; 261 } else { 262 startRoot = null; 263 } 264 System.out.println(); 265 } while (startRoot != null); 266 } 267 268 /** 269 * the abstract node definition, define the operation of leaf node and internal node. 270 * 271 * @param <K> 272 * @param <V> 273 */ 274 abstract class Node<K extends Comparable<K>, V> { 275 276 protected Node<K, V> parent; 277 278 protected Node<K, V> previous, next; 279 280 protected Object[] keys; 281 282 /** 283 * 節點中key的個數 284 */ 285 protected int size; 286 287 protected abstract V get(K key); 288 289 /** 290 * if new parent node is created when insert the key-value, the created parent node is returned, otherwise, this method return null.<br> 291 * 若已存在該key則更新值，結束。<br> 292 * 不然找到應該插入的位置。若插入後不會使得當前節點空間上溢則結束；若會上溢則依次看左右相鄰<b>兄弟節點</b>是否有空間，有則移一個元素到該兄弟節點並進行必要調整（此操做也稱旋轉或借位）；不然當前節點分裂。內部節點的借位和分裂操做與葉子節點的操做不太同樣。 293 * 294 * @param key 295 * @param value 296 * @return 297 */ 298 protected abstract Node<K, V> insert(K key, V value); 299 300 /** 301 * if root is removed, the new root is returned, otherwise, this method return null.<br> 302 * 先刪除，而後判斷：<br> 303 * 若當前節點是根節點則結束；不然若當前節點的空間未下溢則結束；不然依次看左右相鄰<b>兄弟節點</b>是否元素個數大於最小值，如果則借一個元素到當前節點（稱旋轉或借位），不然依次看與左兄弟節點仍是右兄弟節點合併。內部節點的借位和合並操做與葉子節點的操做不太同樣。 <br> 304 * 能夠改進：節點合併時存起該丟棄的節點，在節點分裂時不用new新節點而是複用該節點，以節省空間。 305 * 306 * @param key 307 * @param value 308 * @return 309 */ 310 protected abstract Node<K, V> remove(K key); 311 312 @Override 313 public String toString() { 314 StringBuilder nodeKeyInfo = new StringBuilder(); 315 nodeKeyInfo.append("|"); 316 for (int i = 0; i < this.size; i++) { 317 nodeKeyInfo.append(this.keys[i]); 318 if (i != this.size - 1) { 319 nodeKeyInfo.append(","); 320 } 321 } 322 nodeKeyInfo.append("| "); 323 return nodeKeyInfo.toString(); 324 } 325 } 326 327 /** 328 * the internal node which manages the pointers. 329 * 330 * @param <K> 331 * @param <V> 332 */ 333 final class InternalNode<K extends Comparable<K>, V> extends Node<K, V> { 334 private Node<K, V>[] pointers; 335 336 public InternalNode() { 337 this.size = 0; 338 this.pointers = new Node[MAX_CHILDREN_FOR_INTERNAL]; 339 this.keys = new Object[MAX_CHILDREN_FOR_INTERNAL - 1]; 340 this.parent = null; 341 342 this.previous = null; 343 this.next = null; 344 } 345 346 @Override 347 protected V get(K key) { 348 // int i = 0; 349 // for (; i < this.size; i++) { 350 // if (key.compareTo((K) this.keys[i]) < 0) 351 // break; 352 // } 353 // return this.pointers[i].get(key); 354 LeafNode<K, V> tmpNode = getLeafNodeByKey(key); 355 if (tmpNode == null) { 356 return null; 357 } else { 358 return tmpNode.get(key); 359 } 360 } 361 362 @Override 363 protected Node<K, V> insert(K key, V value) { 364 // int i = 0; 365 // for (; i < this.size; i++) { 366 // if (key.compareTo((K) this.keys[i]) < 0) 367 // break; 368 // } 369 // return this.pointers[i].insert(key, value); 370 LeafNode<K, V> tmpNode = getLeafNodeByKey(key); 371 if (tmpNode == null) { 372 return null; 373 } else { 374 return tmpNode.insert(key, value); 375 } 376 } 377 378 @Override 379 protected Node<K, V> remove(K key) { 380 // TODO Auto-generated method stub 381 LeafNode<K, V> tmpNode = getLeafNodeByKey(key); 382 if (tmpNode == null) { 383 return null; 384 } else { 385 return tmpNode.remove(key); 386 } 387 } 388 389 /** 390 * 根據給定的key獲取應在的LeafNode，即便該LeafNode沒有該key 391 */ 392 public LeafNode<K, V> getLeafNodeByKey(K key) { 393 Node<K, V> tmpNode = this; 394 int i; 395 do { 396 for (i = 0; i < tmpNode.size; i++) { 397 if (key.compareTo((K) tmpNode.keys[i]) < 0) 398 break; 399 } 400 tmpNode = ((InternalNode<K, V>) tmpNode).pointers[i]; 401 } while (tmpNode instanceof InternalNode); 402 return (LeafNode<K, V>) tmpNode; 403 } 404 405 /** 406 * 在當前節點中插入指定的key及其相應左右孩子樹。設key應當在當前節點的關鍵字a、b間，leftChild、rightChild中的任意一個關鍵字分別爲x、y，則有a≤x＜key≤y＜b 407 * 408 * @return 若樹高度增長致使產生新根節點則返回該新根節點，不然返回null 409 */ 410 private Node<K, V> insert(K key, Node<K, V> leftChild, Node<K, V> rightChild) { 411 if (this.size == 0) {// 增長一層 412 // System.out.println("**internal insert " + key + " in 0 of " + this.toString()); 413 this.size++; 414 this.pointers[0] = leftChild; 415 this.pointers[1] = rightChild; 416 this.keys[0] = key; 417 return this; 418 } 419 420 // key應該在的位置 421 int i; 422 for (i = 0; i < this.size; i++) { 423 if (key.compareTo((K) this.keys[i]) < 0) { 424 break; 425 } 426 } 427 // System.out.println("**internal insert " + key + " in " + i + " of " + this.toString()); 428 429 // 未滿，直接插入 430 if (this.size + 1 < MAX_CHILDREN_FOR_INTERNAL) { 431 for (int j = this.size; j > i; j--) { 432 this.keys[j] = this.keys[j - 1]; 433 this.pointers[j + 1] = this.pointers[j]; 434 } 435 this.keys[i] = key; 436 this.pointers[i + 1] = rightChild; 437 this.size++; 438 return null; 439 } 440 // 如下分支：插入後會滿 441 // 442 else if (this.previous != null && (this.previous.parent == this.parent) 443 && this.previous.size < MAX_CHILDREN_FOR_LEAF) {// 旋轉操做：放一個到前一兄弟節點 444 // 找到父節點中分界key的位置 445 Node<K, V> parent = this.parent; 446 K tmpKey = (K) this.keys[0]; 447 int j; 448 for (j = parent.size - 1; j >= 0; j--) { 449 if (tmpKey.compareTo((K) (parent.keys[j])) >= 0) {// 若維護葉節點第一個key等於父節點分界key，則只會＝ 450 break; 451 } 452 } 453 454 // 把當前節點的一個元素放到目標兄弟節點後在當前節點插入key-value，並更新父節點key 455 InternalNode<K, V> toNode = (InternalNode<K, V>) this.previous; 456 457 // 移動一個節點到前一節點 458 toNode.keys[toNode.size] = parent.keys[j]; 459 toNode.pointers[toNode.size + 1] = this.pointers[0]; 460 this.pointers[0].parent = toNode; 461 toNode.size++; 462 463 // 更新父節點key並在當前節點插入新元素 464 if (i == 0) {// 按理應插入到當前節點首位 465 // 更新父節點key 466 parent.keys[j] = key; 467 // 當前節點插入新元素 468 this.pointers[0] = rightChild; 469 } else { 470 // 更新父節點key 471 parent.keys[j] = this.keys[0]; 472 // 當前節點插入新元素.移掉一個元素到目的節點後，待插元素應放在i-1的位置 473 this.pointers[0] = this.pointers[1]; 474 int insertPos = i - 1; 475 for (int k = 0; k < insertPos; k++) { 476 this.keys[k] = this.keys[k + 1]; 477 this.pointers[k + 1] = this.pointers[k + 2]; 478 } 479 this.keys[insertPos] = key; 480 this.pointers[insertPos + 1] = rightChild; 481 } 482 483 return null; 484 485 } else if (this.next != null && (this.next.parent == this.parent) 486 && this.next.size < MAX_CHILDREN_FOR_LEAF) {// 旋轉操做： 放一個到下一兄弟節點 487 488 InternalNode<K, V> toNode = (InternalNode<K, V>) this.next; 489 // 找到父節點中分界key的位置 490 Node<K, V> parent = this.parent; 491 K tmpKey = (K) toNode.keys[0]; 492 int j; 493 for (j = parent.size - 1; j >= 0; j--) { 494 if (tmpKey.compareTo((K) (parent.keys[j])) >= 0) {// 若維護葉節點第一個key等於父節點分界key，則只會＝ 495 break; 496 } 497 } 498 499 // 騰出首位 500 for (int k = toNode.size; k > 0; k--) { 501 toNode.keys[k] = toNode.keys[k - 1]; 502 toNode.pointers[k + 1] = toNode.pointers[k]; 503 } 504 toNode.pointers[1] = toNode.pointers[0]; 505 toNode.size++; 506 507 // 把當前節點的一個元素放到目標兄弟節點後在當前節點插入key-value，並更新父節點key 508 if (i == this.size) { 509 toNode.keys[0] = parent.keys[j]; 510 toNode.pointers[0] = rightChild; 511 rightChild.parent = toNode; 512 513 parent.keys[j] = key; 514 } else { 515 toNode.keys[0] = parent.keys[j]; 516 toNode.pointers[0] = this.pointers[this.size]; 517 toNode.pointers[0].parent = toNode; 518 519 parent.keys[j] = this.keys[this.size - 1]; 520 521 for (int k = this.size - 1; k > i; k--) { 522 this.keys[k] = this.keys[k - 1]; 523 this.pointers[k + 1] = this.pointers[k]; 524 } 525 this.keys[i] = key; 526 this.pointers[i + 1] = rightChild; 527 } 528 529 return null; 530 531 } else {// 分裂 532 // 已滿，須要分裂 533 { 534 // InternalNode<K, V> newNode = new InternalNode<K, V>(); 535 // 536 // int tmpSizeIfInserted = this.size + 1; 537 // // 若是插入後須要被提到父節點的key及其下標，須要確保分裂開的兩節點都至少有一個元素 538 // K parentKey = null; 539 // int m = (tmpSizeIfInserted / 2); 540 // switch (inputDataOrder) { 541 // case ASCENDING: 542 // m = tmpSizeIfInserted - 2; 543 // break; 544 // case DESCENDING: 545 // m = 1; 546 // break; 547 // case RANDOM: 548 // default: 549 // m = (tmpSizeIfInserted / 2); 550 // break; 551 // } 552 // 553 // if (i == m) { 554 // parentKey = key; 555 // // 複製到新節點並刪除原節點裏相應的內容 556 // newNode.pointers[0] = rightChild; 557 // newNode.pointers[0].parent = newNode; 558 // for (int j = m; j < this.size; j++) { 559 // newNode.keys[j - m] = this.keys[j]; 560 // newNode.pointers[j + 1 - m] = this.pointers[j + 1]; 561 // newNode.pointers[j + 1 - m].parent = newNode; 562 // this.keys[j] = null; 563 // this.pointers[j + 1] = null; 564 // newNode.size++; 565 // } 566 // this.size = m; 567 // 568 // } else if (i < m) { 569 // parentKey = (K) this.keys[m - 1]; 570 // // 複製到新節點並刪除原節點裏相應的內容 571 // newNode.pointers[0] = this.pointers[m]; 572 // newNode.pointers[0].parent = newNode; 573 // for (int j = m; j < this.size; j++) { 574 // newNode.keys[j - m] = this.keys[j]; 575 // newNode.pointers[j + 1 - m] = this.pointers[j + 1]; 576 // newNode.pointers[j + 1 - m].parent = newNode; 577 // this.keys[j] = null; 578 // this.pointers[j + 1] = null; 579 // newNode.size++; 580 // } 581 // this.size = m; 582 // 583 // // 插入新內容到原節點 584 // for (int j = m - 1; j > i; j--) { 585 // this.keys[j] = this.keys[j - 1]; 586 // this.pointers[j + 1] = this.pointers[j]; 587 // } 588 // this.keys[i] = key; 589 // this.pointers[i + 1] = rightChild; 590 // } else { 591 // parentKey = (K) this.keys[m]; 592 // // 複製到新節點並刪除原節點裏相應的內容 593 // newNode.pointers[0] = this.pointers[m + 1]; 594 // newNode.pointers[0].parent = newNode; 595 // for (int j = m + 1; j < this.size; j++) { 596 // if (j == i) {// 複製插入的新內容 597 // newNode.keys[newNode.size] = key; 598 // newNode.pointers[newNode.size + 1] = rightChild; 599 // newNode.size++; 600 // } 601 // // 複製原節點的內容 602 // newNode.keys[newNode.size] = this.keys[j]; 603 // newNode.pointers[newNode.size + 1] = this.pointers[j + 1]; 604 // newNode.pointers[newNode.size + 1].parent = newNode; 605 // this.keys[j] = null; 606 // this.pointers[j + 1] = null; 607 // newNode.size++; 608 // } 609 // if (i == this.size) {// 複製插入的新內容 610 // newNode.keys[newNode.size] = key; 611 // newNode.pointers[newNode.size + 1] = rightChild; 612 // newNode.size++; 613 // } 614 // this.size = m; 615 // } 616 // 617 // if (this.parent == null) { 618 // this.parent = new InternalNode<K, V>(); 619 // } 620 // newNode.parent = this.parent; 621 // 622 // // 更新節點間的相鄰關係 623 // newNode.next = this.next; 624 // newNode.previous = this; 625 // if (this.next != null) { 626 // this.next.previous = newNode; 627 // } 628 // this.next = newNode; 629 // 630 // return ((InternalNode<K, V>) this.parent).insert(parentKey, this, newNode); 631 } 632 633 // 原實現 634 System.arraycopy(this.keys, 0, tmpNewKeys, 0, i); 635 tmpNewKeys[i] = key; 636 System.arraycopy(this.keys, i, tmpNewKeys, i + 1, this.size - i); 637 638 System.arraycopy(this.pointers, 0, tmpNewPointers, 0, i + 1); 639 tmpNewPointers[i + 1] = rightChild; 640 System.arraycopy(this.pointers, i + 1, tmpNewPointers, i + 2, this.size - i); 641 642 this.size++; 643 644 // 要被提到父節點的key的下標，須要確保分裂開的兩節點都至少有一個元素 645 int m = (this.size / 2); 646 switch (inputDataOrder) { 647 case ASCENDING: 648 m = this.size - 2; 649 break; 650 case DESCENDING: 651 m = 1; 652 break; 653 case RANDOM: 654 default: 655 m = (this.size / 2); 656 break; 657 } 658 659 // split the internal node 660 InternalNode<K, V> newNode = new InternalNode<K, V>(); 661 662 newNode.size = this.size - m - 1; 663 System.arraycopy(tmpNewKeys, m + 1, newNode.keys, 0, newNode.size); 664 System.arraycopy(tmpNewPointers, m + 1, newNode.pointers, 0, newNode.size + 1); 665 666 // reset the children's parent to the new node. 667 for (int j = 0; j <= newNode.size; j++) { 668 newNode.pointers[j].parent = newNode; 669 } 670 671 this.size = m; 672 673 System.arraycopy(tmpNewKeys, 0, this.keys, 0, m); 674 System.arraycopy(tmpNewPointers, 0, this.pointers, 0, m + 1); 675 676 if (this.parent == null) { 677 this.parent = new InternalNode<K, V>(); 678 } 679 newNode.parent = this.parent; 680 681 // 更新節點間的相鄰關係 682 newNode.next = this.next; 683 newNode.previous = this; 684 if (this.next != null) { 685 this.next.previous = newNode; 686 } 687 this.next = newNode; 688 689 // tmpNewKeys[m]做爲新key插入父節點，此key在分裂後的兩個節點中都不存在 690 return ((InternalNode<K, V>) this.parent).insert((K) tmpNewKeys[m], this, newNode); 691 } 692 } 693 694 /** 695 * 下層節點在觸發合併操做時纔會進入此方法。rightChild丟棄、key刪掉 696 * 697 * @return 若樹高度下降致使產生新根節點則返回該新根節點，不然返回null 698 */ 699 private Node<K, V> remove(K key, Node<K, V> leftChil3d, Node<K, V> rightCh6ild) { 700 // TODO Auto-generated method stub 701 702 // 找key的位置 703 int i; 704 for (i = 0; i < this.size; i++) { 705 if (key.compareTo((K) this.keys[i]) == 0) { 706 break; 707 } 708 } 709 710 // 沒找到，結束 711 if (i == this.size) { 712 return null; 713 } 714 715 // 找到，刪除key對應的記錄、指向合併後被丟棄的子節點（即rightChild也即this.pointers[i + 1]）的指針置空 716 for (; i < this.size - 1; i++) { 717 this.keys[i] = this.keys[i + 1]; 718 this.pointers[i + 1] = this.pointers[i + 2]; 719 } 720 // System.out.println("**internal remove " + key + " in " + i + " of " + this.toString()); 721 this.keys[this.size - 1] = null; 722 this.pointers[this.size] = null; 723 this.size--; 724 725 /* 如下進行調整 */ 726 727 // 當前層只有一個節點的狀況，爲根節點 728 if (this.previous == null && this.next == null) { 729 if (this.size == 0) {// 減小一層 730 Node<K, V> newRoot = (Node<K, V>) (this.pointers[0]); 731 newRoot.parent = null; 732 return newRoot; 733 } else { 734 return null; 735 } 736 } 737 // 如下分支：當前節點有兄弟節點 738 739 else if (this.size >= (MIN_CHILDREN_FOR_INTERNAL - 1)) {// 無須借位、合併，結束 740 return null; 741 } 742 // 如下分支：當前節點有兄弟節點，且刪後當前節點的鍵數爲(MIN_CHILDREN_FOR_INTERNAL - 2)，須要借位或合併 743 744 else if (this.previous != null && (this.previous.parent == this.parent) 745 && this.previous.size > (MIN_CHILDREN_FOR_INTERNAL - 1)) {// 從前一兄弟節點借一個元素 746 InternalNode<K, V> borrowedNode = (InternalNode<K, V>) this.previous; 747 748 /** 設this和previous在parent的分界鍵爲key_parent，previous的最後一鍵和指針爲key_last、pointer_last，則將key_parent、pointer_last做爲新元素插入到this首位且將key_last替代parent的key_parent */ 749 int j; 750 // 後挪空出首位 751 for (j = this.size; j > 0; j--) { 752 this.keys[j] = this.keys[j - 1]; 753 this.pointers[j + 1] = this.pointers[j]; 754 } 755 this.pointers[1] = this.pointers[0]; 756 757 // 找出父節點key所在位置 758 Node<K, V> parent = this.parent; 759 K tmpKey = (this.size == 0) ? key : (K) this.keys[1]; 760 for (j = parent.size - 1; j >= 0; j--) { 761 if (tmpKey.compareTo((K) (parent.keys[j])) > 0) { 762 break; 763 } 764 } 765 766 // 借位操做 767 this.keys[0] = parent.keys[j]; 768 this.pointers[0] = borrowedNode.pointers[borrowedNode.size]; 769 this.pointers[0].parent = this; 770 this.size++; 771 parent.keys[j] = borrowedNode.keys[borrowedNode.size - 1]; 772 borrowedNode.keys[borrowedNode.size - 1] = null; 773 borrowedNode.pointers[borrowedNode.size] = null; 774 borrowedNode.size--; 775 776 return null; 777 778 } else if (this.next != null && (this.next.parent == this.parent) 779 && this.next.size > (MIN_CHILDREN_FOR_INTERNAL - 1)) {// 從後一個兄弟節點借一個元素 780 InternalNode<K, V> borrowedNode = (InternalNode<K, V>) this.next; 781 782 // 找出父節點key所在位置 783 int j; 784 Node<K, V> parent = this.parent; 785 K tmpKey = (K) borrowedNode.keys[0]; 786 for (j = parent.size - 1; j >= 0; j--) { 787 if (tmpKey.compareTo((K) (parent.keys[j])) > 0) { 788 break; 789 } 790 } 791 792 // 借位操做 793 this.keys[this.size] = parent.keys[j]; 794 this.pointers[this.size + 1] = borrowedNode.pointers[0]; 795 this.pointers[this.size + 1].parent = this; 796 this.size++; 797 parent.keys[j] = borrowedNode.keys[0]; 798 799 for (j = 0; j < borrowedNode.size - 1; j++) { 800 borrowedNode.keys[j] = borrowedNode.keys[j + 1]; 801 borrowedNode.pointers[j] = borrowedNode.pointers[j + 1]; 802 } 803 borrowedNode.pointers[j] = borrowedNode.pointers[j + 1]; 804 borrowedNode.keys[borrowedNode.size - 1] = null; 805 borrowedNode.pointers[borrowedNode.size] = null; 806 borrowedNode.size--; 807 808 return null; 809 810 } else if (this.previous != null && (this.previous.parent == this.parent) 811 && this.previous.size == (MIN_CHILDREN_FOR_INTERNAL - 1)) {// 與前一兄弟節點合併。（其實只會＝，不會＜） 812 // parent中的分界key複製到前一節點末尾後當前節點內容複製到前一節點 813 // 合併後目標節點的size爲(MIN_CHILDREN_FOR_INTERNAL - 1) +1+ (MIN_CHILDREN_FOR_INTERNAL - 2) 814 815 InternalNode<K, V> previous = (InternalNode<K, V>) this.previous; 816 817 // 找出父節點分界key所在位置 818 Node<K, V> parent = this.parent; 819 K tmpKey = this.size == 0 ? key : (K) this.keys[0]; 820 int j; 821 for (j = parent.size - 1; j >= 0; j--) { 822 if (tmpKey.compareTo((K) (parent.keys[j])) > 0) { 823 break; 824 } 825 } 826 827 // 合併 828 previous.keys[previous.size] = parent.keys[j]; 829 previous.pointers[previous.size + 1] = this.pointers[0]; 830 this.pointers[0].parent = previous; 831 this.pointers[0] = null;// 複製過去後清空本節點的該元素 832 previous.size++; 833 for (int k = 0; k < this.size; k++) { 834 previous.keys[previous.size + k] = this.keys[k]; 835 previous.pointers[previous.size + k + 1] = this.pointers[k + 1]; 836 this.pointers[k + 1].parent = previous; 837 838 this.keys[k] = null;// 複製過去後清空本節點的該元素，下同 839 this.pointers[k + 1] = null; 840 } 841 previous.size += this.size; 842 this.size = 0;// 複製過去後清空本節點 843 844 // 更新節點相鄰關係 845 previous.next = this.next; 846 if (this.next != null) { 847 this.next.previous = previous; 848 } 849 this.parent = null; 850 this.previous = null; 851 this.next = null; 852 853 return ((InternalNode<K, V>) previous.parent).remove((K) parent.keys[j], previous, this); 854 } else if (this.next != null && (this.next.parent == this.parent) 855 && this.next.size == (MIN_CHILDREN_FOR_INTERNAL - 1)) {// 與後一兄弟節點合併。（其實只會＝，不會＜） 856 // parent中的分界key複製到當前節點末尾後後一節點的內容複製到當前節點 857 // 合併後目標節點的size爲(MIN_CHILDREN_FOR_INTERNAL - 1) +1+ (MIN_CHILDREN_FOR_INTERNAL - 2) 858 859 InternalNode<K, V> next = (InternalNode<K, V>) this.next; 860 861 // 找出父節點分界key所在位置 862 Node<K, V> parent = next.parent; 863 K tmpKey = (K) next.keys[0]; 864 int j; 865 for (j = parent.size - 1; j >= 0; j--) { 866 if (tmpKey.compareTo((K) (parent.keys[j])) > 0) { 867 break; 868 } 869 } 870 871 // 合併 872 this.keys[this.size] = parent.keys[j]; 873 this.pointers[this.size + 1] = next.pointers[0]; 874 next.pointers[0].parent = this; 875 next.pointers[0] = null;// 複製過去後清空本節點的該元素 876 this.size++; 877 for (int k = 0; k < next.size; k++) { 878 this.keys[this.size + k] = next.keys[k]; 879 this.pointers[this.size + k + 1] = next.pointers[k + 1]; 880 next.pointers[k + 1].parent = this; 881 882 next.keys[k] = null;// 複製過去後清空本節點的該元素，下同 883 next.pointers[k + 1] = null; 884 } 885 this.size += next.size; 886 next.size = 0;// 複製過去後清空本節點的該元素 887 888 // 更新節點相鄰關係 889 this.next = next.next; 890 if (next.next != null) { 891 next.next.previous = this; 892 } 893 next.parent = null; 894 next.previous = null; 895 next.next = null; 896 897 return ((InternalNode<K, V>) this.parent).remove((K) parent.keys[j], this, next); 898 } else {// 永遠到不了這 899 System.err.println("wrong in internal node remove."); 900 return null; 901 } 902 } 903 } 904 905 /** 906 * leaf node, store the keys and actual values. 907 * 908 * @param <K> 909 * @param <V> 910 */ 911 final class LeafNode<K extends Comparable<K>, V> extends Node<K, V> { 912 private Object[] values; 913 914 public LeafNode() { 915 this.size = 0; 916 this.keys = new Object[MAX_CHILDREN_FOR_LEAF]; 917 this.values = new Object[MAX_CHILDREN_FOR_LEAF]; 918 this.parent = null; 919 920 this.previous = null; 921 this.next = null; 922 } 923 924 @Override 925 protected V get(K key) { 926 // two branch search 927 if (this.size == 0) { 928 return null; 929 } 930 931 int s = 0, e = this.size - 1; 932 int m = -1; 933 K mKey = null; 934 boolean isFind = false; 935 while (s <= e) { 936 m = (s + e) / 2; 937 mKey = (K) this.keys[m]; 938 if (key.compareTo(mKey) == 0) { 939 isFind = true; 940 break; 941 } else if (key.compareTo(mKey) > 0) { 942 s = m + 1; 943 } else { 944 e = m - 1; 945 } 946 } 947 return isFind ? ((V) this.values[m]) : null; 948 } 949 950 @Override 951 protected Node<K, V> insert(K key, V value) { 952 int i = 0; 953 for (; i < this.size; i++) { 954 K curKey = (K) this.keys[i]; 955 if (curKey.compareTo(key) == 0) {// key已存在，更新值 956 this.values[i] = value; 957 return null; 958 } 959 if (curKey.compareTo(key) > 0) 960 break; 961 } 962 963 dataCount++; 964 // 如下分支：key不存在，插入新key-value 965 966 // 未滿，直接插入 967 if (this.size + 1 <= MAX_CHILDREN_FOR_LEAF) { 968 for (int j = this.size; j > i; j--) { 969 this.keys[j] = this.keys[j - 1]; 970 this.values[j] = this.values[j - 1]; 971 } 972 this.keys[i] = key; 973 this.values[i] = value; 974 this.size++; 975 return null; 976 } 977 // 如下分支：插入後會滿 978 // 979 else if (this.previous != null && (this.previous.parent == this.parent) 980 && this.previous.size < MAX_CHILDREN_FOR_LEAF) {// 旋轉操做：放一個到前一兄弟節點 981 // 找到父節點中分界key的位置 982 Node<K, V> parent = this.parent; 983 K tmpKey = (K) this.keys[0]; 984 int j; 985 for (j = parent.size - 1; j >= 0; j--) { 986 if (tmpKey.compareTo((K) (parent.keys[j])) >= 0) {// 若維護葉節點第一個key等於父節點分界key，則只會＝ 987 break; 988 } 989 } 990 991 // 把當前節點的一個元素放到目標兄弟節點後在當前節點插入key-value，並更新父節點key 992 LeafNode<K, V> toNode = (LeafNode<K, V>) this.previous; 993 if (i == 0) {// 按理應插入到當前節點首位 994 toNode.keys[toNode.size] = key; 995 toNode.values[toNode.size] = value; 996 toNode.size++; 997 } else { 998 toNode.keys[toNode.size] = this.keys[0]; 999 toNode.values[toNode.size] = this.values[0]; 1000 toNode.size++; 1001 1002 // 移掉一個元素到目的節點後，待插元素應放在i-1的位置 1003 int insertPos = i - 1; 1004 for (int k = 0; k < insertPos; k++) { 1005 this.keys[k] = this.keys[k + 1]; 1006 this.values[k] = this.values[k + 1]; 1007 } 1008 this.keys[insertPos] = key; 1009 this.values[insertPos] = value; 1010 } 1011 1012 // 更新它們的父節點的分界key 1013 parent.keys[j] = this.keys[0]; 1014 1015 return null; 1016 1017 } else if (this.next != null && (this.next.parent == this.parent) 1018 && this.next.size < MAX_CHILDREN_FOR_LEAF) {// 旋轉操做： 放一個到下一兄弟節點 1019 LeafNode<K, V> toNode = (LeafNode<K, V>) this.next; 1020 // 找到父節點中分界key的位置 1021 Node<K, V> parent = this.parent; 1022 K tmpKey = (K) toNode.keys[0]; 1023 int j; 1024 for (j = parent.size - 1; j >= 0; j--) { 1025 if (tmpKey.compareTo((K) (parent.keys[j])) >= 0) {// 若維護葉節點第一個key等於父節點分界key，則只會＝ 1026 break; 1027 } 1028 } 1029 1030 // 騰出首位 1031 for (int k = toNode.size; k > 0; k--) { 1032 toNode.keys[k] = toNode.keys[k - 1]; 1033 toNode.values[k] = toNode.values[k - 1]; 1034 } 1035 toNode.size++; 1036 1037 // 把當前節點的一個元素放到目標兄弟節點後在當前節點插入key-value，並更新父節點key 1038 if (i == this.size) { 1039 toNode.keys[0] = key; 1040 toNode.values[0] = value; 1041 } else { 1042 toNode.keys[0] = this.keys[this.size - 1]; 1043 toNode.values[0] = this.values[this.size - 1]; 1044 1045 for (int k = this.size - 1; k > i; k--) { 1046 this.keys[k] = this.keys[k - 1]; 1047 this.values[k] = this.values[k - 1]; 1048 } 1049 this.keys[i] = key; 1050 this.values[i] = value; 1051 } 1052 // 更新它們的父節點的分界key 1053 parent.keys[j] = toNode.keys[0]; 1054 1055 return null; 1056 1057 } else {// 進行分裂 1058 1059 { 1060 // LeafNode<K, V> newNode = new LeafNode<K, V>(); 1061 // int tmpSizeIfInserted = this.size + 1; 1062 // // 若是插入後須要被提到父節點的key及其下標，須要確保分裂開的兩節點都至少有一個元素 1063 // K parentKey = null; 1064 // int m = (tmpSizeIfInserted / 2); 1065 // switch (inputDataOrder) { 1066 // case ASCENDING: 1067 // m = tmpSizeIfInserted - 1; 1068 // break; 1069 // case DESCENDING: 1070 // m = 1; 1071 // break; 1072 // case RANDOM: 1073 // default: 1074 // m = (tmpSizeIfInserted / 2); 1075 // break; 1076 // } 1077 // 1078 // if (i == m) { 1079 // parentKey = key; 1080 // // 複製到新節點並刪除原節點裏相應的內容 1081 // newNode.keys[0] = key; 1082 // newNode.values[0] = value; 1083 // newNode.size++; 1084 // for (int j = m; j < this.size; j++) { 1085 // newNode.keys[j - m + 1] = this.keys[j]; 1086 // newNode.values[j - m + 1] = this.values[j]; 1087 // this.keys[j] = null; 1088 // this.values[j] = null; 1089 // newNode.size++; 1090 // } 1091 // this.size = m; 1092 // 1093 // } else if (i < m) { 1094 // parentKey = (K) this.keys[m - 1]; 1095 // // 複製到新節點並刪除原節點裏相應的內容 1096 // for (int j = m - 1; j < this.size; j++) { 1097 // newNode.keys[j - m + 1] = this.keys[j]; 1098 // newNode.values[j - m + 1] = this.values[j]; 1099 // this.keys[j] = null; 1100 // this.values[j] = null; 1101 // newNode.size++; 1102 // } 1103 // this.size = m; 1104 // 1105 // // 插入新內容到原節點 1106 // for (int j = m - 1; j > i; j--) { 1107 // this.keys[j] = this.keys[j - 1]; 1108 // this.values[j] = this.values[j - 1]; 1109 // } 1110 // this.keys[i] = key; 1111 // this.values[i] = value; 1112 // } else { 1113 // parentKey = (K) this.keys[m]; 1114 // // 複製到新節點並刪除原節點裏相應的內容 1115 // for (int j = m; j < this.size; j++) { 1116 // if (j == i) {// 複製插入的新內容 1117 // newNode.keys[newNode.size] = key; 1118 // newNode.values[newNode.size] = value; 1119 // newNode.size++; 1120 // } 1121 // // 複製原節點的內容 1122 // newNode.keys[newNode.size] = this.keys[j]; 1123 // newNode.values[newNode.size] = this.values[j]; 1124 // this.keys[j] = null; 1125 // this.values[j] = null; 1126 // newNode.size++; 1127 // } 1128 // if (i == this.size) {// 複製插入的新內容 1129 // newNode.keys[newNode.size] = key; 1130 // newNode.values[newNode.size] = value; 1131 // newNode.size++; 1132 // } 1133 // this.size = m; 1134 // } 1135 // if (this.parent == null) {// 只有在剛開始只有一個葉節點且葉節點已滿時才成立 1136 // this.parent = new InternalNode<K, V>(); 1137 // } 1138 // newNode.parent = this.parent; 1139 // 1140 // // 更新葉節點的相鄰關係 1141 // newNode.next = this.next; 1142 // newNode.previous = this; 1143 // if (this.next != null) { 1144 // this.next.previous = newNode; 1145 // } 1146 // this.next = newNode; 1147 // 1148 // return ((InternalNode<K, V>) this.parent).insert(parentKey, this, newNode); 1149 } 1150 1151 // 原實現 1152 System.arraycopy(this.keys, 0, tmpNewKeys, 0, i); 1153 tmpNewKeys[i] = key; 1154 System.arraycopy(this.keys, i, tmpNewKeys, i + 1, this.size - i); 1155 1156 System.arraycopy(this.values, 0, tmpNewValues, 0, i); 1157 tmpNewValues[i] = value; 1158 System.arraycopy(this.values, i, tmpNewValues, i + 1, this.size - i); 1159 1160 this.size++; 1161 1162 // need split this node 1163 int m = this.size / 2; 1164 switch (inputDataOrder) { 1165 case ASCENDING: 1166 m = this.size - 1; 1167 break; 1168 case DESCENDING: 1169 m = 1; 1170 break; 1171 case RANDOM: 1172 default: 1173 m = (this.size / 2); 1174 break; 1175 } 1176 1177 LeafNode<K, V> newNode = new LeafNode<K, V>(); 1178 newNode.size = this.size - m; 1179 System.arraycopy(tmpNewKeys, m, newNode.keys, 0, newNode.size); 1180 System.arraycopy(tmpNewValues, m, newNode.values, 0, newNode.size); 1181 1182 this.size = m; 1183 System.arraycopy(tmpNewKeys, 0, this.keys, 0, m); 1184 System.arraycopy(tmpNewValues, 0, this.values, 0, m); 1185 1186 if (this.parent == null) {// 只有在剛開始只有一個葉節點且葉節點已滿時才成立 1187 this.parent = new InternalNode<K, V>(); 1188 } 1189 newNode.parent = this.parent; 1190 1191 // 更新葉節點的相鄰關係 1192 newNode.next = this.next; 1193 newNode.previous = this; 1194 if (this.next != null) { 1195 this.next.previous = newNode; 1196 } 1197 this.next = newNode; 1198 1199 // 清理無用引用，使GC能回收 1200 1201 // tmpNewKeys[m]做爲新key插入父節點，此key也做爲分裂後後節點的第一個元素 1202 return ((InternalNode<K, V>) this.parent).insert((K) newNode.keys[0], this, newNode); 1203 } 1204 } 1205 1206 @Override 1207 protected Node<K, V> remove(K key) { 1208 // TODO Auto-generated method stub 1209 1210 // 查找key的位置 1211 int i; 1212 for (i = 0; i < this.size; i++) { 1213 if (key.compareTo((K) this.keys[i]) == 0) { 1214 break; 1215 } 1216 } 1217 1218 // 沒找到，結束 1219 if (i == this.size) { 1220 return null; 1221 } 1222 1223 // 找到，刪除key對應的記錄 1224 for (int j = i; j < this.size - 1; j++) { 1225 this.keys[j] = this.keys[j + 1]; 1226 this.values[j] = this.values[j + 1]; 1227 } 1228 // System.out.println("**leaf remove " + key + " in " + i + " of " + this.toString()); 1229 this.keys[this.size - 1] = null; 1230 this.values[this.size - 1] = null; 1231 this.size--; 1232 1233 dataCount--; 1234 1235 /* 如下進行調整 */ 1236 1237 // 樹只有此葉節點，無須借位、合併，結束 1238 if (this.parent == null) { 1239 return null; 1240 } 1241 // 且 刪後記錄數很多於一半，無需借位、合併，結束 1242 else if (this.size >= MIN_CHILDREN_FOR_LEAF) { 1243 if (i == 0) {// 可選操做：刪除了第一個元素，所以須要維持葉節點第一個key與父節點的一個key同樣 1244 Node<K, V> parent = this.parent; 1245 K tmpKey = (K) this.keys[0]; 1246 for (int j = parent.size - 1; j >= 0; j--) { 1247 if (tmpKey.compareTo((K) (parent.keys[j])) >= 0) {// 只會＞ 1248 parent.keys[j] = this.keys[0]; 1249 break; 1250 } 1251 } 1252 } 1253 return null; 1254 } 1255 // 如下分支：有兄弟節點，且刪後節點的鍵數爲MIN_CHILDREN_FOR_LEAF-1，須要借位或合併：優先嚐試借位，借位不成再合併。注意只有兄弟節點間才能借位或合併 1256 1257 else if (this.previous != null && (this.previous.parent == this.parent) 1258 && this.previous.size > MIN_CHILDREN_FOR_LEAF) {// 從前一兄弟節點借一個元素 1259 1260 LeafNode<K, V> borrowedNode = (LeafNode<K, V>) this.previous; 1261 1262 // 取上節點最後一個元素放到當前節點的第一個位置 1263 for (int j = this.size; j > 0; j--) { 1264 this.keys[j] = this.keys[j - 1]; 1265 this.values[j] = this.values[j - 1]; 1266 } 1267 this.keys[0] = borrowedNode.keys[borrowedNode.size - 1]; 1268 this.values[0] = borrowedNode.values[borrowedNode.size - 1]; 1269 this.size++; 1270 borrowedNode.keys[borrowedNode.size - 1] = null; 1271 borrowedNode.values[borrowedNode.size - 1] = null; 1272 borrowedNode.size--; 1273 1274 // 可選操做：更新父節點的key爲借來的元素的key 1275 Node<K, V> parent = this.parent; 1276 K tmpKey = (this.size == 1) ? key : (K) this.keys[1]; 1277 for (int j = parent.size - 1; j >= 0; j--) { 1278 if (tmpKey.compareTo((K) (parent.keys[j])) >= 0) {// 若維護葉節點第一個key等於父節點分界key，則只會＝ 1279 parent.keys[j] = this.keys[0]; 1280 break; 1281 } 1282 } 1283 return null; 1284 1285 } else if (this.next != null && (this.next.parent == this.parent) 1286 && this.next.size > MIN_CHILDREN_FOR_LEAF) {// 從後一兄弟節點借一個元素 1287 1288 LeafNode<K, V> borrowedNode = (LeafNode<K, V>) this.next; 1289 1290 // 取下節點的第一個元素放到當前節點的最後一個位置 1291 this.keys[this.size] = borrowedNode.keys[0]; 1292 this.values[this.size] = borrowedNode.values[0]; 1293 this.size++; 1294 for (int j = 0, len = borrowedNode.size - 1; j < len; j++) { 1295 borrowedNode.keys[j] = borrowedNode.keys[j + 1]; 1296 borrowedNode.values[j] = borrowedNode.values[j + 1]; 1297 } 1298 borrowedNode.keys[borrowedNode.size - 1] = null; 1299 borrowedNode.values[borrowedNode.size - 1] = null; 1300 borrowedNode.size--; 1301 1302 // 可選操做：更新父節點的key爲被借節點的新首元素 1303 Node<K, V> parent = this.parent; 1304 K tmpKey = (K) this.keys[this.size - 1]; 1305 for (int j = parent.size - 1; j >= 0; j--) { 1306 if ((tmpKey).compareTo((K) parent.keys[j]) >= 0) {// 若維護葉節點第一個key等於父節點分界key，則只會＝ 1307 parent.keys[j] = borrowedNode.keys[0]; 1308 break; 1309 } 1310 } 1311 return null; 1312 1313 } else if (this.previous != null && (this.previous.parent == this.parent) 1314 && this.previous.size == MIN_CHILDREN_FOR_LEAF) {// 與前一兄弟節點合併。（其實只會＝，不會＜） 1315 // 找出父節點分界key所在位置 1316 K dividKey = this.size == 0 ? key : (K) this.keys[0]; 1317 1318 // 當前節點的內容複製到前一節點，合併後目標節點的size爲MIN_CHILDREN_FOR_LEAF + (MIN_CHILDREN_FOR_LEAF-1) 1319 LeafNode<K, V> previous = (LeafNode<K, V>) this.previous; 1320 for (int j = 0; j < this.size; j++) { 1321 previous.keys[previous.size + j] = this.keys[j]; 1322 previous.values[previous.size + j] = this.values[j]; 1323 1324 this.keys[j] = null;// 複製過去後清空本節點的該元素，下同 1325 this.values[j] = null; 1326 } 1327 previous.size += this.size; 1328 this.size = 0;// 複製過去後清空本節點的該元素 1329 1330 // 更新葉節點相鄰關係 1331 previous.next = this.next; 1332 if (this.next != null) { 1333 this.next.previous = previous; 1334 } 1335 this.parent = null; 1336 this.previous = null; 1337 this.next = null; 1338 1339 // key及父節點中指向當前節點的poniter會在父節點執行刪除方法時被覆蓋，從而當前節點被刪除 1340 return ((InternalNode<K, V>) previous.parent).remove(dividKey, previous, this); 1341 1342 } else if (this.next != null && (this.next.parent == this.parent) 1343 && this.next.size == MIN_CHILDREN_FOR_LEAF) {// 與後一兄弟節點合併。（其實只會＝，不會＜） 1344 // 找出父節點分界key所在位置 1345 K dividKey = (K) next.keys[0]; 1346 1347 // 後一節點的內容複製到當前節點，合併後目標節點的size爲MIN_CHILDREN_FOR_LEAF + (MIN_CHILDREN_FOR_LEAF-1) 1348 LeafNode<K, V> next = (LeafNode<K, V>) this.next; 1349 for (int j = 0; j < next.size; j++) { 1350 this.keys[this.size + j] = next.keys[j]; 1351 this.values[this.size + j] = next.values[j]; 1352 1353 next.keys[j] = null;// 複製過去後清空本節點的該元素，下同 1354 next.values[j] = null; 1355 } 1356 this.size += next.size; 1357 next.size = 0;// 複製過去後清空本節點的該元素 1358 1359 // 更新葉節點相鄰關係 1360 this.next = next.next; 1361 if (next.next != null) { 1362 next.next.previous = this; 1363 } 1364 next.parent = null; 1365 next.previous = null; 1366 next.next = null; 1367 1368 return ((InternalNode<K, V>) this.parent).remove(dividKey, this, next); 1369 } else {// 永遠到不了這 1370 System.err.println("wrong in leaf node remove."); 1371 return null; 1372 } 1373 } 1374 } 1375 }
1 package buaa.act.ucar.imtg.index.node.temporal; 2 3 import java.lang.management.ManagementFactory; 4 import java.lang.management.MemoryMXBean; 5 import java.lang.management.MemoryUsage; 6 import java.text.SimpleDateFormat; 7 import java.util.Date; 8 import java.util.HashMap; 9 import java.util.Map; 10 import java.util.Random; 11 12 import buaa.act.ucar.imtg.index.node.temporal.BPlusTree.InputDataOrder; 13 import scala.collection.generic.BitOperations.Int; 14 15 /** 16 * @author zsm 17 * @date 2017年1月11日 上午11:24:58 18 */ 19 public class BPlusTreeTest { 20 public static void main(String[] args) { 21 BPlusTree<Integer, Integer> bPlusTree = new BPlusTree<>(5, InputDataOrder.RANDOM); 22 for (int i = 0; i < 100; i++) { 23 bPlusTree.set(i, i); 24 } 25 bPlusTree.remove(4); 26 bPlusTree.printTree(); 27 System.out.println(bPlusTree.getAllValues()); 28 } 29 30 public static void ma3in(String[] args) { 31 MemoryMXBean memorymbean = ManagementFactory.getMemoryMXBean(); 32 // memorymbean.setVerbose(true); 33 Runtime myRuntime = Runtime.getRuntime(); 34 35 long firinit, firused, fircommited, firmax; 36 long sedmax, sedtotal, sedfree, sedused; 37 double rad = 1024 * 1024.0; 38 SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm:ss"); 39 Date date; 40 MemoryUsage usage; 41 42 BPlusTree<String, Integer> tree = new BPlusTree<>(5, InputDataOrder.RANDOM); 43 for (int j = 0; j < 60000; j++) { 44 for (int i = 10_000_000; i > 0; i--) { 45 // tree.set(i + "", i); 46 } 47 48 usage = memorymbean.getHeapMemoryUsage(); 49 date = new Date(); 50 firinit = usage.getInit(); 51 firused = usage.getUsed(); 52 fircommited = usage.getCommitted(); 53 firmax = usage.getMax(); 54 55 sedmax = myRuntime.maxMemory(); 56 sedtotal = myRuntime.totalMemory(); 57 sedfree = myRuntime.freeMemory(); 58 sedused = sedtotal - sedfree; 59 60 System.out.printf( 61 "by MemoryUsage: %s init(%dB≈%.4fMB), used(%dB≈%.4fMB), commited(%dB≈%.4fMB), max(%dB≈%.4fMB)\n", 62 simpleDateFormat.format(date), firinit, firinit / rad, firused, firused / rad, fircommited, 63 fircommited / rad, firmax, firmax / rad); 64 65 System.out.printf( 66 "by Runtime: %s free(%dB≈%.4fMB), used(%dB≈%.4fMB), total(%dB≈%.4fMB), max(%dB≈%.4fMB)\n", 67 simpleDateFormat.format(date), sedfree, sedfree / rad, sedused, sedused / rad, sedtotal, 68 sedtotal / rad, sedmax, sedmax / rad); 69 System.out.println(); 70 try { 71 Thread.sleep(4000); 72 } catch (InterruptedException e) { 73 // TODO Auto-generated catch block 74 e.printStackTrace(); 75 } 76 } 77 78 // System.err.println("add:"); 79 // for (int i = 1; i <= 41; i++) { 80 // tree.set(i, i); 81 // tree.printTree(tree.getRoot()); 82 // } 83 // System.out.println("height:" + tree.getHeight()); 84 // tree.printTree(tree.getRoot()); 85 // 86 // System.err.println("remove:"); 87 // tree.remove(21); 88 // tree.printTree(tree.getRoot()); 89 // tree.remove(22); 90 // tree.printTree(tree.getRoot()); 91 // tree.remove(23); 92 // tree.printTree(tree.getRoot()); 93 94 // test2(); 95 } 96 97 public static int getRandom(int min, int max, boolean isMaxInclude) { 98 return new Random().nextInt(max - min + (isMaxInclude ? 1 : 0)) + min; 99 } 100 101 /** 隨機產生數據，並進行查詢、刪除 */ 102 public static void test2() { 103 BPlusTree<Integer, Integer> myTree = new BPlusTree<Integer, Integer>(10, InputDataOrder.RANDOM); 104 105 int max = 10_000_000; 106 int min = -max; 107 int numCount = max - min + 1; 108 int numRealCount = 0; 109 110 Integer[] data = new Integer[max - min + 1]; 111 for (int i = 0; i < data.length; i++) { 112 data[i] = 0; 113 } 114 115 // 產生數據 116 long start = System.currentTimeMillis(); 117 int key; 118 for (int i = 0; i < numCount; i++) { 119 key = getRandom(min, max, true); 120 // key = i + min; 121 // try { 122 // Thread.sleep(1000); 123 // } catch (InterruptedException e) { 124 // // TODO Auto-generated catch block 125 // e.printStackTrace(); 126 // } 127 myTree.set(key, key); 128 if (data[key - min] == 0) { 129 numRealCount++; 130 data[key - min] = 1; 131 } 132 } 133 System.out.println( 134 numRealCount + " data from " + numCount + "[" + min + "," + max + "] has been inserted into tree"); 135 System.out.println("time cost for insert: " + (System.currentTimeMillis() - start)); 136 System.out.println("tree leaf entry: " + myTree.getDataCount() + ", hashmap count:" + numRealCount); 137 138 // 查數據 139 System.out.println(); 140 System.out.println("getDataCount:" + myTree.getDataCount()); 141 System.out.println("height:" + myTree.getHeight()); 142 start = System.currentTimeMillis(); 143 int getCount = 0; 144 for (int i = 0; i < data.length; i++) { 145 if (data[i] == 1) { 146 getCount++; 147 key = i + min; 148 if (!myTree.get(key).equals(key)) { 149 System.err.println("error for get: " + myTree.get(key) + " " + key); 150 System.exit(1); 151 } 152 } 153 } 154 System.out.println("time cost for " + getCount + " get: " + (System.currentTimeMillis() - start)); 155 156 // 刪除數據 157 System.out.println(); 158 start = System.currentTimeMillis(); 159 System.out.println(myTree.getDataCount()); 160 for (int i = data.length; i >= 0; i--) { 161 try { 162 myTree.remove(i + min); 163 } catch (Exception e) { 164 // TODO: handle exception 165 System.err.println(String.format("remove error: i=%d, key=%d \n", i, i + min)); 166 e.printStackTrace(); 167 System.exit(0); 168 } 169 } 170 System.out.println("getDataCount:" + myTree.getDataCount()); 171 System.out.println("height:" + myTree.getHeight()); 172 myTree.printTree(); 173 myTree.remove(-2); 174 System.out.println("time cost for remove: " + (System.currentTimeMillis() - start)); 175 } 176 177 public static void test1() { 178 BPlusTree<Integer, Integer> myTree = new BPlusTree<Integer, Integer>(8, InputDataOrder.RANDOM); 179 180 int max = 200 * 25000; 181 long start = System.currentTimeMillis(); 182 for (int i = 0; i < max; i++) { 183 myTree.set(i, i); 184 } 185 System.out.println(max + " Data has been inserted into tree"); 186 System.out.println("time cost for BPlusTree: " + (System.currentTimeMillis() - start)); 187 188 System.out.println(); 189 System.out.println("height: " + myTree.getHeight()); 190 System.out.println(myTree.get(2345)); 191 System.out.println(); 192 193 start = System.currentTimeMillis(); 194 for (int i = 0; i < max; i++) { 195 myTree.get(i); 196 } 197 System.out.println("time cost for get: " + (System.currentTimeMillis() - start)); 198 199 start = System.currentTimeMillis(); 200 Map<Integer, String> hashMap = new HashMap<Integer, String>(); 201 for (int i = 0; i < max; i++) { 202 hashMap.put(i, i + ""); 203 } 204 System.out.println("time cost for HashMap: " + (System.currentTimeMillis() - start)); 205 206 for (int i = 0; i < max; i++) { 207 if (myTree.get(i) != i) { 208 System.err.println("error for: " + i); 209 } 210 } 211 212 System.out.println("Success"); 213 214 // myTree.remove(2); 215 // myTree.printTree(myTree.getRoot()); 216 } 217 218 public static void test3() { 219 BPlusTree<Integer, String> myTree = new BPlusTree<Integer, String>(3, InputDataOrder.RANDOM); 220 221 int max = 7; 222 for (int i = 0; i < max; i++) { 223 // System.out.println("__insert " + i); 224 myTree.set(i, i + ""); 225 // myTree.printTree(myTree.getRoot()); 226 // System.out.println(); 227 228 // System.out.println("__insert " + (2 * max - i)); 229 myTree.set(2 * max - i, 2 * max - i + ""); 230 // myTree.printTree(myTree.getRoot()); 231 // System.out.println(); 232 } 233 234 System.out.println("tree height:" + myTree.getHeight()); 235 System.out.println("leaf entry count:" + myTree.getDataCount()); 236 System.out.println(); 237 238 myTree.printTree(); 239 System.out.println(); 240 241 for (int i = 0; i < max; i++) { 242 System.out.println("__remove " + i); 243 myTree.remove(i); 244 myTree.printTree(); 245 246 System.out.println("__remove " + (2 * max - i)); 247 myTree.remove(2 * max - i); 248 myTree.printTree(); 249 System.out.println(); 250 } 251 252 } 253 254 }
三、其餘
一、二叉樹與樹、森林的轉換
二叉樹與通常樹的雙向轉換、與森林的雙向轉換。（通常樹轉爲二叉樹後根節點度爲1，包含多棵樹的森林轉爲二叉樹後根節點度爲2）。二叉樹轉爲樹或森林時，該二叉樹須是由後者轉換而來的。
二、樹、森林的遍歷：
a、二叉樹：前序、中序、後序、層次
b、樹：前序、後序
c、森林：前序（即按樹的前序遍歷依次遍歷每棵樹）、中序（即按樹的後序遍歷方式依次遍歷每棵樹，尼瑪叫後序更合適吧）
將樹或森林轉爲二叉樹或反向轉換後：（不用記，舉個例子就明瞭了）
二叉樹的前序、樹的前序、森林的前序遍歷序列同樣
二叉樹的中序、樹的後序、森林的中序（尼瑪你若叫後序遍歷這裏就統一了）同樣
相關文章
- 1. 《數據結構與算法》——樹與二叉樹之線索二叉樹總結
- 2. 數據結構之樹與二叉樹
- 3. 【數據結構】樹與二叉樹
- 4. 數據結構2 樹與二叉樹
- 5. 數據結構之二叉樹總結
- 6. 數據結構 5-0 樹與二叉樹總結
- 7. 數據結構-二叉樹、滿二叉樹、完全二叉樹
- 8. 數據結構——二叉樹
- 9. 【數據結構】 二叉樹
- 10. 數據結構--二叉樹
- 更多相關文章...
- • XML 樹結構 - XML 教程
- • Rust 結構體 - RUST 教程
- • 算法總結-二分查找法
- • 算法總結-雙指針
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 《數據結構與算法》——樹與二叉樹之線索二叉樹總結
- 2. 數據結構之樹與二叉樹
- 3. 【數據結構】樹與二叉樹
- 4. 數據結構2 樹與二叉樹
- 5. 數據結構之二叉樹總結
- 6. 數據結構 5-0 樹與二叉樹總結
- 7. 數據結構-二叉樹、滿二叉樹、完全二叉樹
- 8. 數據結構——二叉樹
- 9. 【數據結構】 二叉樹
- 10. 數據結構--二叉樹