平衡二叉樹演算法分析__演算法

目錄(?)[+] 1、平衡二叉樹定義： 

平衡二叉樹（Balanced Binary Tree或Height-Balanced Tree）又稱AVL樹。它或者是一顆空樹，或者是具有下列性質的二叉樹：它的左子樹和右子樹都是平衡二叉樹，且左子樹和右子樹的深度之差的絕對值不超過1。若將二叉樹上結點的平衡因子bf(balance factor)定義為該結點的左子樹的深度減去右子樹的深度，則平衡二叉樹上所有結點的平衡因子只可能為-1、0和1這三個值。

  2、失去平衡情況分析：

假設結點A是一顆子平衡二叉樹，當在以A為根結點的AVL樹上插入一個新結點時，會出現以下三種情況：

1）如果插入前A—>bf=1（A的左子樹深度比右子樹深度多1），如果插入在A的左子樹上且A的左子樹深度增加了1，則此時A—>bf=2需要對樹進行調整，如圖2.1結點C為新插入的結點，C可以插入到B的左子樹上（如圖2.1（b））或者右子樹上（如圖2.1（c））。

2）如果插入前A—>bf=0（A的左子樹和右子樹深度相等），如果插入在A的左子樹上且A的左子樹深度增加了1，則此時只需要改變A的平衡因子為1即可不需要對樹進行調整。如果插入在A的右子樹上且A的右子樹深度增加了1，則此時只需要改變A的平衡因子為-1即可不需要進行調整。

3）如果插入前A—>bf=-1（A的左子樹深度比右子樹深度少1），如果插入在A的右子樹上且A的右子樹深度增加了1，則此時A—>bf=-2需要對樹進行調整，如圖2.2結點C為新插入的結點，C可以插入在B的左子樹上（如圖2.2（b））或者右子樹上（如圖2.2（c））。

                            

　　　　　　　　             圖2.1　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　                圖2.2

　　　　　　　　　　　　注意：上圖中為了清楚的看到添加結點後失去平衡時的情況，省去了一些子結點，這些結點在下面的分析中會完整畫出來

 

當出現圖2.1（b）中的情況時只需要進行一次右旋轉操作，旋轉後得到如圖2.1（d）所示的平衡二叉樹。

當出現圖2.1（c）中的情況時需要先對A的左子樹B進行左旋操作，然後再進行右旋操作，旋轉後得到如圖2.1（e）所示的平衡二叉樹。

當出現圖2.2（b）中的情況時只需要進行一次右旋轉操作，旋轉後得到如圖2.1（d）所示的平衡二叉樹。

當出現圖2.2（c）中的情況時需要先對A的右子樹B進行右旋，然後再進行左旋操作，旋轉後得到如圖2.2（e）所示的平衡二叉樹。

  3.求旋轉後各結點的平衡因子：

旋轉後怎麼確定各結點的新的平衡因子是平衡二叉樹演算法的關鍵點，我們需要按情況來一一推理。

一、當出現圖2.1（b）（c）這兩種情況時，需進行左平衡處理：

1）當新結點插入到B的左子樹上時B—>bf=1，由此可知：deep(C)=deep(E)+1，deep(B)=deep(C)+1；由於插入新結點前A—>bf=1，deep(B)=deep(D)+1則插入新節點後deep(B)=deep(D)+2；圖3.1.1為調整前的二叉樹，圖3.1.2為對A樹進行右旋轉後的AVL樹：

                                              

          　　　　　　圖3.1.1                                                                                                         圖3.1.2

對比圖3.1.1和3.1.2可知旋轉後的新樹中A的左子樹發生了變化，B的右子樹發生了變化，其他結點都沒變；因此只需要重新算出A的平衡因子和B的平衡因子即可證明調整後的樹是否為AVL樹。

由上面的等式deep(B)=deep(D)+2，deep(B)=deep(C)+1，deep(C)=deep(E)+1

可以推出deep(E)=deep(C)-1=deep(B)-1-1=deep(D)+2-1-1=deep(D)可得出A—>bf=0

由調整後deep(E)=deep(D)可推出調整後deep(A)=deep(E)+1=deep(C)-1+1=deep(C)可得出B—>bf=0；

2）當新結點插入到B的右子樹上時B—>bf=-1，由此可知：deep(C)=deep(E)-1，deep(B)=deep(E)+1；由於插入新結點前A—>bf=1，deep(B)=deep(D)+1則插入新節點後deep(B)=deep(D)+2；圖3.2.1為調整前的二叉樹，圖3.2.2為先對B樹進行左旋然後對A樹進行右旋後的AVL樹：

                                                      

                  圖3.2.1                                                                                                                                 圖3.2.2

對比圖3.2.1和3.2.2可知調整後的新樹中A的左子樹發生了變化，B的右子樹發生了變化，E的左右子樹都發生了變化，其他結點都沒變，因此只需要重新算出A的平衡因子、B的平衡因子以及E的平衡因子即可證明調整後的樹是否為AVL樹。

此時由於調整後的B和A結點的平衡因子與E的左右子樹EL和ER有關，因此需要根據E的平衡因子的不同來進行分析：

由上面的分析可得到deep(B)=deep(D)+2，deep(B)=deep(E)+1，deep(C)=deep(E)-1

1、當E—>bf=1時：deep(E)=deep(EL)+1，deep(ER)=deep(EL)-1

deep(C)=deep(E)-1=deep(EL)+1-1=deep(EL)可得B—>bf=0

deep(D)=deep(B)-2=deep(E)+1-2=deep(ER)+1+1+1-2=deep(ER)+1可得A—>bf=-1

由於deep(EL)=deep(ER)+1所以E—>bf=0

2、當E—>bf=0時：deep(E)=deep(EL)+1，deep(ER)=deep(EL)

deep(C)=deep(E)-1=deep(EL)+1-1=deep(EL)可得B—>bf=0

deep(D)=deep(B)-2=deep(E)+1-2=deep(ER)+1+1-2=deep(ER)可得A—>bf=0

由於B—>bf=0，A—>bf=0所以E—>bf=0

3、當E—>bf=-1時：deep(E)=deep(ER)+1，deep(ER)=deep(EL)+1

deep(C)=deep(E)-1=deep(EL)+1+1-1=deep(EL)+1可得B—>bf=1

deep(D)=deep(B)-2=deep(E)+1-2=deep(ER)+1+1-2=deep(ER)可得A—>bf=0

由於deep(EL)=deep(ER)-1所以E—>bf=0

二、當出現圖2.2（b）（c）這兩種情況時，需進行右平衡處理：

1）當新結點插入到C的左子樹上時C—>bf=1,由此可知：deep(C)=deep(E)+1，deep(D)=deep(E)-1；由於插入新結點前A—>bf=-1，deep(B)=deep(C)-1則插入新節點後deep(B)=deep(C)-2；圖3.3.1為調整前的二叉樹，圖3.3.2為先對C樹進行右旋然後對A樹進行左旋後的AVL樹：

                                                    

              　　　　圖3.3.1　　                                                                                                         圖3.3.2　

對比圖3.3.1和3.3.2可知調整後的新樹中A的右子樹發生了變化，C的左子樹發生了變化，E的左右子樹都發生了變化，其他結點都沒變，因此只需要重新算出A的平衡因子、B的平衡因子以及E的平衡因子即可證明調整後的樹是否為AVL樹。

此時由於調整後的A和C結點的平衡因子與E的左右子樹EL和ER有關，因此需要根據E的平衡因子的不同來進行分析：

由上面的分析可得到deep(B)=deep(C)-2，deep(C)=deep(E)+1，deep(D)=deep(E)-1

1、當E—>bf=1時：deep(E)=deep(EL)+1，deep(ER)=deep(EL)-1

deep(B)=deep(C)-2=deep(EL)+1+1-2=deep(EL)可得A—>bf=0

deep(D)=deep(E)-1=deep(ER)+1+1-1=deep(ER)+1可得C—>bf=-1

由於deep(EL)=deep(ER)+1所以E—>bf=0

2、當E—>bf=0時：deep(E)=deep(EL)+1，deep(ER)=deep(EL)

deep(B)=deep(E)+1-2=deep(EL)+1+1-2=deep(EL)可得A—>bf=0

deep(D)=deep(E)-1=deep(ER)+1-1=deep(ER)可得C—>bf=0

由於A—>bf=0,C—>bf=0所以E—>bf=0

3、當E—>bf=-1時：deep(E)=deep(ER)+1，deep(ER)=deep(EL)+1

deep(B)=deep(C)-2=deep(E)+1-2=deep(EL)+1+1+1-2=deep(EL)+1可得A—>bf=1

deep(D)=deep(E)-1=deep(ER)+1-1=deep(ER)可得C—>bf=0

由於deep(EL)=deep(ER)-1所以E—>bf=0

 

2）當新結點插入到C的右子樹上時C—>bf=-1，由此可知：deep(C)=deep(D)+1，deep(D)=deep(E)+1；由於插入新結點前A—>bf=-1，deep(B)=deep(C)-1則插入新節點後deep(B)=deep(C)-2；圖3.4.1為調整前的二叉樹，圖3.4.2為進行左旋後的AVL樹：

                                                   

                           圖3.4.1　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　                      　圖3.4.2

對比圖3.4.1和3.4.2可知調整後的新樹中A的右子樹發生了變化，C的左子樹發生了變化，其他結點都沒變，因此只需要重新算出A的平衡因子和C的平衡因子即可證明調整後的樹是否為AVL樹。

由上面的等式deep(B)=deep(C)-2，deep(C)=deep(D)+1，deep(D)=deep(E)+1

可以推出deep(B)=deep(C)-2=deep(D)+1-2=deep(E)+1+1-2=deep(E)可得出A—>bf=0

由A—>bf=0調整後deep(A)=deep(E)+1=deep(D)-1+1=deep(D)可得出C—>bf=0； 4.Java實現代碼：

  1 package org.algorithms.tree;  2   3 import java.util.concurrent.ConcurrentLinkedQueue;  4   5   6 public class BalanceBiTree<T> {  7   8     private Node root;  9      10     private int size; 11      12     public void insert(T t){ 13         if(root==null){ 14             root = new Node(); 15             root.bf = 0; 16             root.data = t; 17             size++; 18             return; 19         } 20         addNode(root,t); 21     } 22      23     private boolean addNode(Node nd,T t){ 24         boolean taller = false; 25         Comparable<T> cp = (Comparable<T>)nd.data; 26         int i = cp.compareTo(t); 27         if(i==0){ 28             return false; 29         }else if(i>0){ 30             if(nd.lChild==null){ 31                 Node child = new Node(); 32                 child.bf = 0; 33                 child.data = t; 34                 child.parent = nd; 35                 nd.lChild = child; 36                 size++; 37                 if(nd.bf==0){ 38                     nd.bf = 1; 39                     return true; 40                 } 41                 nd.bf = 0; 42             }else{ 43                 taller = addNode(nd.lChild, t); 44                 if(taller){ 45                     if(nd.bf==1){ 46                         leftBalance(nd); 47                         taller = false; 48                     }else if(nd.bf==0){ 49                         nd.bf = 1; 50                         taller = true; 51                     }else{ 52                         nd.bf = 0; 53                         taller = false; 54                     } 55                 } 56             } 57         }else{ 58             if(nd.rChild==null){ 59                 Node child = new Node(); 60                 child.bf = 0; 61                 child.data = t; 62                 child.parent = nd; 63                 nd.rChild = child; 64                 size++; 65                 if(nd.bf==0){ 66                     nd.bf = -1; 67                     return true; 68                 } 69                 nd.bf = 0; 70             }else{ 71                 taller = addNode(nd.rChild, t); 72                 if(taller){ 73                     if(nd.bf==1){ 74                         nd.bf = 0; 75                         taller = false; 76                     }else if(nd.bf==0){ 77                         nd.bf = -1; 78                         taller = true; 79                     }else{ 80                         rightBalance(nd); 81                         taller = false; 82                     } 83                 } 84             } 85         } 86         return taller; 87     } 88      89     public int getSize(){ 90         return size; 91     } 92      93     private void leftBalance(Node nd){ 94         Node leftChild = nd.lChild; 95         if(leftChild.bf==1){ 96             nd.bf = 0; 97             leftChild.bf = 0; 98             rightRotate(nd); 99         }else if(leftChild.bf==-1){100             Node rd = leftChild.rChild;101             switch (rd.bf) {102             case 1:103                 leftChild.bf=0;nd.bf = -1;104                 break;105             case 0:106                 leftChild.bf=0;nd.bf = 0;107                 break;108             case -1:109                 leftChild.bf = 1;nd.bf = 0;110                 break;111             }112             rd.bf = 0 ;113             leftRotate(leftChild);114             rightRotate(nd);115         }116     }117     118     private void rightBalance(Node nd){119         Node rightChild = nd.rChild;120         if(rightChild.bf==1){121             Node ld = rightChild.lChild;122             switch (ld.bf) {123             case 1:124                 rightChild.bf= -1; nd.bf = 0;125                 break;126             case 0:127                 rightChild.bf=0;nd.bf = 0;128                 break;129             case -1:130                 rightChild.bf = 0;nd.bf = 1;131                 break;132             }133             ld.bf = 0 ;134             rightRotate(rightChild);135             leftRotate(nd);136         }else if(rightChild.bf==-1){137             nd.bf = 0;138             rightChild.bf = 0;139             leftRotate(nd);140         }141         142     }143     144     private void leftRotate(Node nd){145         Node top = nd.rChild;146         nd.rChild = top.lChild;147         if(top.lChild!=null)148             top.lChild.parent = nd;149         top.lChild = nd;150         top.parent = nd.parent;151         if(nd.parent!=null){152             if(nd.parent.lChild == nd)153                 nd.parent.lChild = top;154             else155                 nd.parent.rChild = top;156         }else{157             root = top;158         }159         nd.parent = top;160     }161     162     private void rightRotate(Node nd){163         Node top = nd.lChild;164         nd.lChild = top.rChild;165         if(top.rChild!=null)166             top.rChild.parent = nd;167         top.rChild = nd;168         top.parent = nd.parent;169         if(nd.parent!=null){170             if(nd.parent.lChild == nd)171                 nd.parent.lChild = top;172             else173                 nd.parent.rChild = top;174         }else{175             root = top;176         }177         nd.parent = top;178     }179     180     public void printTree(){181         ConcurrentLinkedQueue<Node> queue = new ConcurrentLinkedQueue<Node>();182         ConcurrentLinkedQueue<Node> tempQueue = new ConcurrentLinkedQueue<Node>();183         queue.add(root);184         int offset= 0;185         int counter=2;186