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 else
155 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 else
173 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 for(int i=0;i<50;i++) 187 System.out.print(" "); 188 while(queue.peek()!=null){ 189 Node node = queue.poll(); 190 String side = "L"; 191 if(node.parent!=null&&node.parent.rChild==node) 192 side = "R"; 193 System.out.print(node.data+"("+(node.parent==null?"":node.parent.data)+" "+side+")"); 194 if(node.parent!=null&&node.parent.rChild!=node) 195 for(int i=0;i<counter;i++) 196 System.out.print(" "); 197 if(node.lChild!=null) 198 tempQueue.add(node.lChild); 199 if(node.rChild!=null) 200 tempQueue.add(node.rChild); 201 if(queue.isEmpty()){ 202 offset += 3; 203 //counter--;
204 copyQueue(tempQueue,queue); 205 System.out.println(); 206 for(int i=0;i<50-offset;i++) 207 System.out.print(" "); 208 } 209 } 210
211 } 212
213 private void copyQueue(ConcurrentLinkedQueue<Node> source, 214 ConcurrentLinkedQueue<Node> target){ 215 while(source.peek()!=null){ 216 target.add(source.poll()); 217 } 218 } 219
220 private class Node{ 221
222 public T data; 223
224 public Node lChild; 225
226 public Node rChild; 227
228 public Node parent; 229
230 public int bf; 231 } 232 }
