由于程序太長，分成了幾部分，后面附上源碼。

1 /** 2 * 平衡二叉搜索（排序）樹 3 * 4 * 平衡二叉搜索樹雙稱為AVL樹，它也是一棵二叉搜索樹，是對二叉搜索樹的一種改進，或都是具有下列性質的二叉樹：它 5 * 的左子樹和右子樹都是平衡二叉樹，且左子樹和右子樹的深度之差的絕對值不超過1。 6 * 7 * 平衡因子（Balance Factor,BF）定義為該節點的左子樹的深度減去其右子樹的深度，則平衡二叉樹上所有節點的平 8 * 衡因子只可能是-1、0和1。只要樹上有一個節點的平衡因子的絕對值大于1，則該二叉樹就是不平衡的了。 9 * 10 * 使用二叉排序樹保持平衡的基本思想是：每當在二叉排序樹中插入一個節點時，首先檢查是否因插入而破壞了平衡，若 11 * 是，則找出其中的最小不平衡二叉樹，在保持二叉排序樹特性的情況下，調整最小不平衡子s樹中節點之間的關系，以達 12 * 到新的平衡。所謂最小不平衡子樹指離插入節點最近且以平衡因子的絕對值大于1的節點作為根的子樹。 13 * 14 * 對于平衡二叉搜索樹，保持樹的平衡的基本機制就是旋轉。旋轉是對樹的元素順序進行調節。旋轉的目的是消除由于臨 15 * 時插入和刪除對樹的平衡產生的影響。 16 * 17 * 有四種旋轉： 18 * 1)繞某元素左旋轉 19 * 80 ← p 90 20 * /\ /\ 21 * 60 90 ← r → 80 120 22 * /\ /\ / 23 * 85 120 60 85 100 24 * / 25 * 100 26 * 27 * 2)繞某元素右旋轉 28 * p → 100 85 29 * /\ /\ 30 * l → 85 120 → 60 100 31 * /\ \ /\ 32 * 60 90 80 90 120 33 * \ 34 * 80 35 * 36 * 3)繞某元素的左子節點左旋轉，接著再繞該元素自己右旋轉。此情況下就是 左旋與右旋 的結合，具體操作時可以分 37 * 解成這兩種操作，只是圍繞點不一樣而已 38 * 39 * 先繞100的左子節點80左旋轉，接著再繞100左旋轉 40 * 41 * 左旋 右旋 42 * 100 → p → 100 → 90 43 * /\ /\ /\ 44 * p → 80 120 l → 90 120 80 100 45 * /\ / /\ \ 46 * 60 90 ← r 80 60 85 120 47 * / /\ 48 * 85 60 85 49 * 50 * 4)繞某元素的右子節點右旋轉，接著再繞該元素自己左旋轉。此情況下就是 右旋與左旋 的結合，具體操作時可以分解 51 * 成這兩種操作，只是圍繞點不一樣而已 52 * 53 * 先繞80的右子節點80右旋轉，接著再繞80左旋轉 54 * 右旋 左旋 55 * 80 → 80 ← p → 85 56 * /\ /\ /\ 57 * 60 100 ← p 60 85 ← r 80 100 58 * /\ \ / /\ 59 * l → 85 120 100 60 90 120 60 * \ /\ 61 * 90 90 120 62 * 63 * 平衡二叉樹實現類 AVLTree 中的很多方法與排序二叉樹是一新的，詳細請參考 BinSearchTree 類中相應方法 64 * 65 * AVLTree中的Entry對象與BinSearchTree中的Entry對象是有區別的，所以AVLTree類不能是BinSearchTree的 66 * 了類，雖然很多的方法是一樣的（如：contains、getEntry、successor、iterator），還有一些方法（add、de 67 * leteEntry）只是在操作后增加了節點平衡因子調整動作，但不能直接繼承于它。 68 * 69 * 二叉搜索樹與平衡二叉搜索樹沒有在Java集合框架中實現，但RED-BLACK樹在TreeMap實現過，當然TreeSet也是， 70 * 因為它是基于TreeMap實現的，TreeSet對象基本上就是一個忽略了每個元素值部分的TreeMap對象。 71 * 72 */

?

1 package tree.avl; 2 3 import java.util.AbstractSet; 4 import java.util.Iterator; 5 6 /** 7 * 平衡二叉搜索（排序）樹 8 * 9 * @author jzj 10 * @data 2009-12-25 11 */ 12 public class AVLTree<E extends Comparable<E>> extends AbstractSet<E> { 13 private Entry<E> root;//根節點 14 private int size;//樹節點個數 15 16 private static class Entry<E> { 17 E elem;//數據域 18 Entry<E> parent;//父節點 19 Entry<E> left;//左節點 20 Entry<E> right;//右節點 21 /* 22 * 樹的平衡因子，等號表示左子樹和右子樹有同樣的高度。如果L，左子樹比右子樹高1。如果為R，則意味著右 23 * 子樹比左高1。剛創建時是平衡的，所以為= 24 * 50 25 * /R\ 26 * 20 80 27 * /L /R\ 28 * 10 70 100 29 * = = /=\ 30 * 92 103 31 * = = 32 */ 33 char balanceFactor = '='; 34 35 //構造函數只有兩個參數，左右節點是調用add方法時設置 36 public Entry(E elem, Entry<E> parent) { 37 this.elem = elem; 38 this.parent = parent; 39 } 40 } 41 42 private class TreeIterator implements Iterator<E> { 43 44 private Entry<E> lastReturned = null; 45 private Entry<E> next; 46 47 TreeIterator() { 48 49 next = root; 50 if (next != null) 51 while (next.left != null) 52 next = next.left; 53 54 } 55 56 public boolean hasNext() { 57 58 return next != null; 59 60 } 61 62 public E next() { 63 64 lastReturned = next; 65 next = successor(next); 66 return lastReturned.elem; 67 68 } 69 70 public void remove() { 71 72 if (lastReturned.left != null && lastReturned != null) 73 next = lastReturned; 74 deleteEntry(lastReturned); 75 lastReturned = null; 76 77 } 78 } 79 80 /** 81 * 左旋轉：結果就是將p移到它的左子節點的位置，而p的右子節點被移到該元素原來位置 82 * @param p 旋轉元素 83 */ 84 private void rotateLeft(Entry<E> p) { 85 /* 86 * 圍繞50左旋轉: 87 *p → 50 90 88 * \ /\ 89 * r → 90 → 50 100 90 * \ 91 * 100 92 * 93 * 圍繞80左旋轉:r的左子樹變成p的右子樹。因為位于r的左子樹上的任意一個元素值大于p且小于r，所以r的左子 94 * 樹可以成為p的右子樹這是沒有問題的。其實上面也發生了同樣的現象，只是r的左子樹為空罷了 95 * p → 80 90 96 * /\ /\ 97 * 60 90 ← r → 80 120 98 * /\ /\ / 99 * 85 120 60 85 100 100 * / 101 * 100 102 * 103 * 圍繞80在更大范圍內旋轉：元素不是圍繞樹的根旋轉。旋轉前后的樹都是二叉搜索樹。且被旋轉元素80上的所 104 * 有元素在旋轉中不移動（50、30、20、40這四個元素還是原來位置） 105 * 50 50 106 * / \ / \ 107 * 30 80 ← p 30 90 108 * /\ /\ /\ / \ 109 * 20 40 60 90 ← r → 20 40 80 120 110 * /\ /\ / 111 * 85 120 60 85 100 112 * / 113 * 100 114 * 115 * 節點數據結構: 116 * +------------------+ 117 * | elem | p | l | r | 118 * +------------------+ 119 * 120 * +------------------+ 121 * | 50 |NULL|NULL| r | 122 * +------------------+ 123 * ↖⑥ ↘④ 124 * +---------------+ 125 * |80| p | l | r | ← p 126 * +---------------+ 127 * ↗ ↙ ↖③ ↘① 128 * +----------------+ +---------------+ 129 * |60| p |NULL|NULL| |90| p | l | r | ← r 130 * +----------------+ +---------------+ 131 * ↗② ↙⑤ ↖↘ 132 * +----------------+ +---------------+ 133 * |85| p |NULL|NULL| |90| p | l |NULL| 134 * +----------------+ +---------------+ 135 * ↗ ↙ 136 * +-----------------+ 137 * |100| p |NULL|NULL| 138 * +-----------------+ 139 */ 140 141 Entry<E> r = p.right;//旋轉元素的右子節點 142 //把旋轉元素的右子節點的左子節點接到旋轉元素的右子樹 143 p.right = r.left;//① 144 //如果旋轉元素的右子節點存在左子節點的話，同時修改該節點的父節指針指向 145 if (r.left != null) { 146 //把旋轉元素的右子節點的左子節點的父設置成旋轉元素 147 r.left.parent = p;//② 148 } 149 //將旋轉元素的右子節點的父設置成旋轉元素的父，這里有可以p為根節點，那么旋轉后p就成根節點 150 r.parent = p.parent;//③ 151 152 //如果旋轉元素為根元素，則旋轉后，旋轉元素的右子節點r將成為根節點 153 if (p.parent == null) { 154 root = r; 155 }//否則p不是根節點，如果p是他父節點的左節點時 156 else if (p.parent.left == p) { 157 //讓p的父節點的左指針指向r 158 p.parent.left = r; 159 }//否則如果p是他父節點的右節點時 160 else { 161 //讓p的父節點的右指針指向r 162 p.parent.right = r;//④ 163 } 164 //讓旋轉元素的左節點指向旋轉元素p 165 r.left = p;//⑤ 166 //讓旋轉元素的父節點指向旋轉元素右節點r 167 p.parent = r;//⑥ 168 } 169 170 /** 171 * 右旋轉：結果就是將p移到它的右子節點的位置，而p的左子節點被移到該元素原來位置 172 * 與左旋轉是完全對稱的，將左旋轉中的lef與rigth互換即可得到，這里就不詳細解釋了 173 * @param p 旋轉元素 174 */ 175 private void rotateRight(Entry<E> p) { 176 177 /* 178 * 圍繞100右旋轉: 179 * p → 100 90 180 * / /\ 181 * l → 90 → 50 100 182 * / 183 * 50 184 * 185 * 圍繞80右旋轉:l的右子樹變成p的左子樹。因為位于l的右子樹上的任意一個元素值小于p且小于l，所以l的右 186 * 子樹可以成為p的左子樹這是沒有問題的。其實上面也發生了同樣的現象，只是l的右子樹為空罷了 187 * 188 * p → 80 60 189 * /\ /\ 190 * l → 60 90 → 50 80 191 * /\ \ /\ 192 * 50 70 55 70 90 193 * \ 194 * 55 195 */ 196 197 Entry<E> l = p.left; 198 p.left = l.right; 199 if (l.right != null) { 200 l.right.parent = p; 201 } 202 l.parent = p.parent; 203 204 if (p.parent == null) { 205 root = l; 206 } else if (p.parent.right == p) { 207 p.parent.right = l; 208 } else { 209 p.parent.left = l; 210 } 211 l.right = p; 212 p.parent = l; 213 } 214 215 /** 216 * AVLTree類的add方法類似于BinSerrchTree類的add方法，但是沿著根向下前進到插入點時，需記錄這樣一個被插 217 * 入Entry對象最近的祖先：該祖先的平衡因子balanceFactor值是L或R(即不殲)，且讓ancestor指向這個祖先節 218 * 點，該祖先節有什么用呢，從ancestor的子開始到新增節點路徑上的所有祖先節點都是平衡，這些祖先節點會因為 219 * 新增節點而變得不平衡了，需要重新調整平衡因子，這個分界點在調整平衡因子時非常有用 220 * 221 * @param elem 要新增元素的數據域 222 * @return 223 */ 224 public boolean add(E elem) { 225 //如果樹為空，則直接插入 226 if (root == null) { 227 root = new Entry<E>(elem, null); 228 size++; 229 return true; 230 } else { 231 Entry<E> tmp = root;//新增節點的父節點，從根節點下面開始找插入點 232 Entry<E> ancestor = null;//平衡因子不為 = 的最近祖先節點 233 int comp; //比較結果 234 while (true) {//死循環，直接找到插入點退出循環 235 comp = elem.compareTo(tmp.elem); 236 //如果已存在該元素，則直接返回失敗 237 if (comp == 0) { 238 return false; 239 } 240 241 //記錄不平衡的祖先節點 242 if (tmp.balanceFactor != '=') { 243 //如果哪個祖先節點不平衡，則記錄，當循環完后，ancestor指向的就是最近一個 244 //不平衡的祖先節點 245 ancestor = tmp; 246 } 247 248 //如果小于當前比較節點，則在其左邊插入 249 if (comp < 0) { 250 251 //如果左子樹不為空，繼續循環在左邊找插入點 252 if (tmp.left != null) { 253 tmp = tmp.left; 254 } else {//否則插入 255 tmp.left = new Entry<E>(elem, tmp); 256 //插入后要進行平衡調整 257 fixAfterInsertion(ancestor, tmp.left); 258 size++; 259 return true; 260 } 261 } else {//在右邊插入 262 263 //如果右子樹不為空，繼續循環在右邊找插入點 264 if (tmp.right != null) { 265 tmp = tmp.right; 266 } else {//否則插入 267 tmp.right = new Entry<E>(elem, tmp); 268 //插入后要進行平衡調整 269 fixAfterInsertion(ancestor, tmp.right); 270 size++; 271 return true; 272 } 273 } 274 275 } 276 } 277 } 278 279 /** 280 * 當新增節點后，會改變某些節點的平衡因子，所以添加節點后需重新調整平衡因子 281 * 282 * 根據前人們的分析與研究，可分為6種情況 283 * 284 * @param ancestor 新增元素的最近一個不平衡的祖先節點 285 * @param inserted 新增元素 286 */ 287 protected void fixAfterInsertion(Entry<E> ancestor, Entry<E> inserted) { 288 E elem = inserted.elem; 289 290 if (ancestor == null) { 291 /* 292 * 情況1：ancestor的值為null，即被插入Entry對象的每個祖先的平衡因子都是 =，此時新增節點后 293 * ，樹的高度不會發生變化，所以不需要旋轉，我們要作的就是調整從根節點到插入節點的路徑上的所有 294 * 節點的平衡因子罷了 295 * 296 * 新增55后調整 297 * 50 → 50 298 * /=\ /R\ 299 * 25 70 25 70 300 * /=\ /=\ /=\ /L\ 301 * 15 30 60 90 15 30 60 90 302 * = = = = = = /L = 303 * 55 304 * = 305 */ 306 //根節點的平衡因子我們單獨拿出來調整，因為adjustPath的參數好比是一個開區間，它不包括兩頭參數 307 //本身，而是從nserted.paraent開始到to的子節點為止，所以需單獨調整，其他分支也一樣 308 if (elem.compareTo(root.elem) < 0) { 309 root.balanceFactor = 'L'; 310 } else { 311 root.balanceFactor = 'R'; 312 } 313 //再調用adjustPath方法調整新增節點的父節點到root的某子節點路徑上的所有祖先節點的 314 //平衡因子 315 adjustPath(root, inserted); 316 } else if ((ancestor.balanceFactor == 'L' && elem.compareTo(ancestor.elem) > 0) 317 || (ancestor.balanceFactor == 'R' && elem.compareTo(ancestor.elem) < 0)) { 318 /* 319 * 情況2： 320 * ancestor.balanceFactor的值為 L，且在ancestor對象的右子樹插入，或ancestor.balanceFac 321 * tor的值為 R，且在ancestor對象的左子樹插入，這兩插入方式都不會引起樹的高度發生變化，所以我們 322 * 也不需要旋轉，直接調整平衡因子即可 323 * 新增55后調整 324 * ancestor → 50 → 50 325 * /L\ /=\ 326 * 25 70 25 70 327 * /R\ /=\ /R\ /L\ 328 * 15 30 60 90 15 30 60 90 329 * /L /L /L 330 * 28 28 55 331 * 新增28后調整 332 * ancestor → 50 → 50 333 * /R\ /=\ 334 * 25 70 25 70 335 * /=\ /L\ /R\ /L\ 336 * 15 30 60 90 15 30 60 90 337 * /L /L /L 338 * 55 28 55 339 */ 340 //先設置ancestor的平衡因子為 平衡 341 ancestor.balanceFactor = '='; 342 //然后按照一般策略對inserted與ancestor間的元素進行調整 343 adjustPath(ancestor, inserted); 344 } else if (ancestor.balanceFactor == 'R' 345 && elem.compareTo(ancestor.right.elem) > 0) { 346 /* 347 * 情況3： 348 * ancestor.balanceFactor的值為 R，并且被插入的Entry位于ancestor的右子樹的右子樹上， 此 349 * 種情況下會引起樹的不平衡，所以先需繞ancestor進行旋轉，再進行平衡因子的調整 350 * 351 * 新增93 先調整因子再繞70左旋 352 * → 50 → 50 353 * /R\ /R\ 354 * 25 70 ← ancestor 25 90 355 * /L /R\ /L /=\ 356 * 15 60 90 15 70 98 357 * = = /=\ = /=\ /L 358 * 80 98 60 80 93 359 * = /= = = = 360 * 93 361 * = 362 */ 363 ancestor.balanceFactor = '='; 364 //圍繞ancestor執行一次左旋 365 rotateLeft(ancestor); 366 //再調整ancestor.paraent（90）到新增節點路徑上祖先節點平衡 367 adjustPath(ancestor.parent, inserted); 368 } else if (ancestor.balanceFactor == 'L' 369 && elem.compareTo(ancestor.left.elem) < 0) { 370 /* 371 * 情況4： 372 * ancestor.balanceFactor的值為 L，并且被插入的Entry位于ancestor的左子樹的左子樹上， 373 * 此種情況下會引起樹的不平衡，所以先需繞ancestor進行旋轉，再進行平衡因子的調整 374 * 375 * 新增13 先調整因子再繞50右旋 376 * → 50 ← ancestor → 20 377 * /L\ /=\ 378 * 20 70 10 50 379 * /=\ /=\ /R\ /=\ 380 * 10 30 60 90 5 15 30 70 381 * /=\ /=\= = = /L /=\ /=\ 382 * 5 15 25 35 13 25 35 60 90 383 * = /= = = = = = = = 384 * 13 385 * = 386 */ 387 ancestor.balanceFactor = '='; 388 //圍繞ancestor執行一次右旋 389 rotateRight(ancestor); 390 //再調整ancestor.paraent（20）到新增節點路徑上祖先節點平衡 391 adjustPath(ancestor.parent, inserted); 392 } else if (ancestor.balanceFactor == 'L' 393 && elem.compareTo(ancestor.left.elem) > 0) { 394 /* 395 * 情況5： 396 * ancestor.balanceFactor的值為 L，并且被插入的Entry位于ancestor的左子樹的右子樹上。此 397 * 種情況也會導致樹不平衡，此種與第6種一樣都需要執行兩次旋轉（執行一次繞ancestor的左子節點左 398 * 旋，接著執行一次繞ancestor執行一次右旋）后，樹才平衡，最后還需調用 左-右旋 專有方法進行平衡 399 * 因子的調整 400 */ 401 rotateLeft(ancestor.left); 402 rotateRight(ancestor); 403 //旋轉后調用 左-右旋 專有方法進行平衡因子的調整 404 adjustLeftRigth(ancestor, inserted); 405 } else if (ancestor.balanceFactor == 'R' 406 && elem.compareTo(ancestor.right.elem) < 0) { 407 408 /* 409 * 情況6： 410 * ancestor.balanceFactor的值為 R，并且被插入的Entry位于ancestor的右子樹的 左子樹上，此 411 * 種情況也會導致樹不平衡，此種與第5種一樣都需要執行兩次旋轉（執行一次繞ancestor的右子節點右旋 412 * ，接著執行一次繞ancestor執行一次左旋）后，樹才平衡，最后還需調用 右-左旋 專有方法進行平衡因 413 * 子的調整 414 */ 415 rotateRight(ancestor.right); 416 rotateLeft(ancestor); 417 //旋轉后調用 右-左旋 專有方法進行平衡因子的調整 418 adjustRigthLeft(ancestor, inserted); 419 } 420 }

?

1 /** 2 * 調整指定路徑上的節點的平衡因子 3 * 4 * 注，指定的路徑上的所有節點一定是平衡的，因此如果被插入元素小于某個祖先節點， 5 * 則這個祖先節點新的平衡因子是 L，反之為 R。 6 * 7 * @param inserted 從哪里元素開始向上調整，但不包括該，即從父開始） 8 * @param to 直到哪個元素結束,但不包括該元素，一般傳進來的為ancestor 9 */ 10 protected void adjustPath(Entry<E> to, Entry<E> inserted) { 11 E elem = inserted.elem; 12 Entry<E> tmp = inserted.parent; 13 //從新增節點的父節點開始向上回溯調整，直到結尾節點to止 14 while (tmp != to) { 15 /* 16 * 插入30，則在25右邊插入，這樣父節點平衡會被打破，右子樹就會比左子樹高1，所以平衡因子為R；祖 17 * 先節點50的平衡因子也被打破，因為在50的左子樹上插入的，所以對50來說，左子樹會比右子樹高1，所 18 * 以其平衡因子為L 19 * 50 50 20 * /=\ 插入30 /L\ 21 * 25 70 → 25 70 22 * = = R\ = 23 * 30 24 * = 25 */ 26 //如果新增元素比祖先節點小，則是在祖先節點的左邊插入，則自然該祖先的左比右子樹會高1 27 if (elem.compareTo(tmp.elem) < 0) { 28 29 tmp.balanceFactor = 'L'; 30 } else { 31 //否則會插到右邊，那么祖先節點的右就會比左子樹高1 32 tmp.balanceFactor = 'R'; 33 } 34 tmp = tmp.parent;//再調整祖先的祖先 35 } 36 } 37 38 /** 39 * 進行 左-右旋轉 后平衡因子調整 40 * 分三種情況 41 * @param ancestor 42 * @param inserted 43 */ 44 protected void adjustLeftRigth(Entry<E> ancestor, Entry<E> inserted) { 45 E elem = inserted.elem; 46 if (ancestor.parent == inserted) { 47 /* 48 * 第1種，新增的節點在旋轉完成后為ancestor父節點情況： 49 * 50 * 新增40 繞30左旋 繞50右旋 51 * → 50 ← ancestor → 50 → 52 * /L /L 53 * 30 40 54 * =\ /= 55 * 40 30 56 * = = 57 * 58 * 調整平衡因子 59 * 40 → 40 60 * /=\ /=\ 61 * 30 50 30 50 62 * = L = = 63 * 64 * 注，這里的 左-右旋 是在fixAfterInsertion方法中的第5種情況中完成的，在這里只是平衡因子的 65 * 調整，圖是為了好說明問題而放在這個方法中的，下面的兩個分支也是一樣 66 */ 67 ancestor.balanceFactor = '='; 68 } else if (elem.compareTo(ancestor.parent.elem) < 0) { 69 /* 70 * 第2種，新增的節點在旋轉完成后為不為ancestor父節點，且新增節點比旋轉后ancestor的父節點要小 71 * 的情況 72 * 73 * 由于插入元素(35)比旋轉后ancestor(50)的父節點(40)要小， 所以新增節點會在其左子樹中 74 * 75 * 新增35 繞20左旋 76 * → 50 ← ancestor → 50 77 * /L\ /L\ 78 * 20 90 40 90 79 * /=\ /=\ /=\ /=\ 80 * 10 40 70 100 20 45 70 100 81 * /=\ /=\= = /=\ 82 * 5 15 30 45 10 30 83 * = = =\ = /=\ =\ 84 * 35 5 15 35 85 * = = = = 86 * 87 * 繞50右旋 調整平衡因子 88 * → 40 → 40 89 * /=\ /=\ 90 * 20 50 20 50 91 * /=\ /L\ /=\ /R\ 92 * 10 30 45 90 10 30 45 90 93 * /=\ =\ /=\ /=\ R\ /=\ 94 * 5 15 35 70 100 5 15 35 70 100 95 * = = = = = = = = = = 96 * 97 */ 98 ancestor.balanceFactor = 'R'; 99 //調整ancestor兄弟節點到插入點路徑上節點平衡因子 100 adjustPath(ancestor.parent.left, inserted); 101 } else { 102 /* 103 * 第2種，新增的節點在旋轉完成后為不為ancestor父節點，且新增節點比旋轉后ancestor的父節點要大的 104 * 情況 105 * 106 * 由于插入元素(42)比旋轉后ancestor(50)的父節點(40)要大，所以新增節點會在其右子樹中 107 * 108 * 新增42 繞20左旋 109 * → 50 ← ancestor → 50 110 * /L\ /L\ 111 * 20 90 40 90 112 * /=\ /=\ /=\ /=\ 113 * 10 40 70 100 20 45 70 100 114 * /=\ /=\= = /=\ /= 115 * 5 15 30 45 10 30 42 116 * = = = /= /=\= = 117 * 42 5 15 118 * = = = 119 * 120 * 繞50右旋 調整平衡因子 121 * → 40 → 40 122 * /=\ /=\ 123 * 20 50 20 50 124 * /=\ /L\ /L\ /=\ 125 * 10 30 45 90 10 30 45 90 126 * /=\ /= /=\ /=\ /L /=\ 127 * 5 15 42 70 100 5 15 42 70 100 128 * = = = = = = = = = = 129 * 130 */ 131 ancestor.parent.left.balanceFactor = 'L'; 132 133 ancestor.balanceFactor = '='; 134 //調整ancestor節點到插入點路徑上節點平衡因子 135 adjustPath(ancestor, inserted); 136 } 137 } 138 139 /** 140 * 進行 右-左旋轉 后平衡因子調整 141 * 142 * 與adjustLeftRigth方法一樣，也有三種情況，這兩個方法是對稱的 143 * @param ancestor 144 * @param inserted 145 */ 146 protected void adjustRigthLeft(Entry<E> ancestor, Entry<E> inserted) { 147 E elem = inserted.elem; 148 if (ancestor.parent == inserted) { 149 /* 150 * 第1種，新增的節點在旋轉完成后為ancestor父節點情況： 151 * 152 * 新增40 繞50右旋 繞30左旋 153 * → 30 ← ancestor → 30 → 154 * R\ R\ 155 * 50 40 156 * /= =\ 157 * 40 50 158 * = = 159 * 160 * 40 調整平衡因子 40 161 * /=\ → /=\ 162 * 30 50 30 50 163 * R = = = 164 * 165 * 注，這里的 右-左旋 是在fixAfterInsertion方法中的第6種情況中完成的，這里只是 平衡因子的調 166 * 整，圖是為了好說明問題而放在這個方法中的，下面的兩個分支也是一樣 167 */ 168 ancestor.balanceFactor = '='; 169 } else if (elem.compareTo(ancestor.parent.elem) > 0) { 170 /* 171 * 第2種，新增的節點在旋轉完成后為不為ancestor父節點，且新增節點比旋轉后 172 * ancestor的父節點要大的情況 173 * 174 * 由于插入元素(73)比旋轉后ancestor(50)的父節點(70)要大， 所以新增節點會 175 * 在其右子樹中 176 * 177 * 新增73 繞90右旋 178 * → 50 ← ancestor → 50 179 * /R\ /R\ 180 * 20 90 20 70 181 * /=\ /=\ /=\ /=\ 182 * 10 40 70 95 10 40 65 90 183 * = = /=\ /=\ = = = /=\ 184 * 65 75 93 97 75 95 185 * = /= = = /= /=\ 186 * 73 73 93 97 187 * = 188 * 189 * 繞50左旋 調整平衡因子 190 * → 70 → 70 191 * /=\ /=\ 192 * 50 90 50 90 193 * /R\ /=\ /L\ /=\ 194 * 20 65 75 95 20 65 75 95 195 * /=\ = /= /=\ /=\ = /L /=\ 196 * 10 40 73 93 97 10 40 73 93 97 197 * = = = = = = = = = = 198 * 199 */ 200 ancestor.balanceFactor = 'L'; 201 adjustPath(ancestor.parent.right, inserted); 202 } else { 203 /* 204 * 第2種，新增的節點在旋轉完成后為不為ancestor父節點，且新增節點比旋轉后ancestor的父節點要小 205 * 的情況 206 * 207 * 由于插入元素(73)比旋轉后ancestor(50)的父節點(70)要大， 所以新增節點會在其右子樹中 208 * 209 * 新增63 繞90右旋 210 * → 50 ← ancestor → 50 211 * /R\ /R\ 212 * 20 90 20 70 213 * /=\ /=\ /=\ /=\ 214 * 10 40 70 95 10 40 65 90 215 * = = /=\ /=\ = = /= /=\ 216 * 65 75 93 97 63 75 95 217 * /= = = = = = /=\ 218 * 63 93 97 219 * = = = 220 * 221 * 繞50左旋 調整平衡因子 222 * → 70 → 70 223 * /=\ /=\ 224 * 50 90 50 90 225 * /R\ /=\ /=\ /R\ 226 * 20 65 75 95 20 65 75 95 227 * /=\ /= = /=\ /=\ /L /=\ 228 * 10 40 63 93 97 10 40 63 93 97 229 * = = = = = = = = = = 230 */ 231 ancestor.parent.right.balanceFactor = 'R'; 232 ancestor.balanceFactor = '='; 233 adjustPath(ancestor, inserted); 234 } 235 } 236 237 /** 238 * 刪除指定節點 239 * 240 * @param elem 241 * @return boolean 242 */ 243 public boolean remove(E elem) { 244 Entry<E> e = getEntry(elem); 245 if (e == null) 246 return false; 247 deleteEntry(e); 248 return true; 249 } 250 251 private Entry<E> getEntry(E e) { 252 Entry<E> tmp = root; 253 int c; 254 while (tmp != null) { 255 c = e.compareTo(tmp.elem); 256 if (c == 0) { 257 return tmp; 258 } else if (c < 0) { 259 tmp = tmp.left; 260 } else { 261 tmp = tmp.right; 262 } 263 } 264 return null; 265 } 266 267 private void deleteEntry(Entry<E> p) { 268 if (p.left != null && p.right != null) { 269 270 Entry<E> s = successor(p); 271 272 p.elem = s.elem; 273 274 p = s; 275 } 276 277 if (p.left == null && p.right == null) { 278 279 if (p.parent == null) { 280 root = null; 281 } else if (p == p.parent.left) { 282 p.parent.left = null; 283 } else { 284 p.parent.right = null; 285 } 286 287 } else { 288 289 Entry<E> rep; 290 if (p.left != null) { 291 rep = p.left; 292 } else { 293 rep = p.right; 294 } 295 296 rep.parent = p.parent; 297 298 if (p.parent == null) { 299 root = rep; 300 } else if (p == p.parent.left) { 301 p.parent.left = rep; 302 } else { 303 p.parent.right = rep; 304 } 305 306 } 307 fixAfterDeletion(p.elem, p.parent); 308 309 p.parent = null; 310 p.left = null; 311 p.right = null; 312 313 size--; 314 } 315 316 /** 317 * 查找指定節點的中序遍歷序列的直接后繼節點，此方法的實現與二叉搜索樹類（BinSearchTree.java）的此方法是 318 * 一樣的，具體的思路請參考二叉搜索樹類中的相應方法 319 * 320 * @param e 需要查找哪個節點的直接后繼節點 321 * @return Entry<E> 直接后繼節點 322 */ 323 private Entry<E> successor(Entry<E> e) { 324 if (e == null) { 325 return null; 326 }//如果待找的節點有右子樹，則在右子樹上查找 327 else if (e.right != null) { 328 //默認后繼節點為右子節點（如果右子節點沒有左子樹時即為該節點） 329 Entry<E> p = e.right; 330 while (p.left != null) { 331 //注，如果右子節點的左子樹不為空，則在左子樹中查找，且后面找時要一直向左拐 332 p = p.left; 333 } 334 return p; 335 }//如果待查節點沒有右子樹，則要在祖宗節點中查找后繼節點 336 else { 337 338 //默認后繼節點為父節點（如果待查節點為父節點的左子樹，則后繼為父節點） 339 Entry<E> p = e.parent; 340 Entry<E> c = e;//當前節點，如果其父不為后繼，則下次指向父節點 341 //如果待查節點為父節點的右節點時，繼續向上找，一直要找到c為左子節點，則p才是后繼 342 while (p != null && c == p.right) { 343 c = p; 344 p = p.parent; 345 } 346 return p; 347 } 348 }

?

1 /** 2 * 刪除節點后平衡調整實現 3 * 4 * @param elem 被刪除節點的數據域 5 * @param ancestor 被刪除節點的祖先節點，從父節點向上迭代 6 */ 7 protected void fixAfterDeletion(E elem, Entry<E> ancestor) { 8 9 boolean heightHasDecreased = true;//樹的高度是否還需要減小 10 11 /* 12 * 1、如果刪除的是根節點，則ancestor為空，此時不需調整了，直接退出 13 * 2、如果刪除的不是根節點，且根節點都已調整，則退出 14 * 3、如果刪除的不是根節點，且樹的高度不需再減小（heightHasDecreased為false），退出 15 */ 16 while (ancestor != null && heightHasDecreased) { 17 18 int comp = elem.compareTo(ancestor.elem); 19 20 /* 21 * 當要刪除的節點有左右子樹時，comp就會等于0，比如下面要刪除33這個節點，刪除方法deleteEntry 22 * 會用36替換掉33節點中的數據的elem，刪除后會調用fixAfterDeletion(p.elem, p.parent)方 23 * 法來調整平衡因子，p又是指向的36，所以p.elem與p.parent.elem是相等的，都是36 24 * 25 * 82 26 * /L\ 27 * 42 95 28 * /=\ R\ 29 * 33 48 96 30 * /=\ /=\ 31 * 29 36 43 75 32 */ 33 34 //從ancestor的右子樹中刪除節點 35 if (comp >= 0) { 36 // ancestor 的平衡因子為 '=' 37 if (ancestor.balanceFactor == '=') { 38 39 /* 刪除15 調整因子 40 * 20 → 20 41 * /L\ /L\ 42 * → 10 50 10 50 43 * /=\ /L 44 * 5 15 5 45 */ 46 ancestor.balanceFactor = 'L'; 47 heightHasDecreased = false; 48 49 } // ancestor 的平衡因子為 'R' 50 else if (ancestor.balanceFactor == 'R') { 51 /* 刪除15 調整因子 下次循環調整20的因子 52 * 20 → → 20 ← ancestor → ... 53 * /L\ /L\ 54 * → 10 50 10 50 55 * /R\ R\ /=\ R\ 56 * 5 15 60 5 18 60 57 * R\ 58 * 18 59 */ 60 ancestor.balanceFactor = '='; 61 ancestor = ancestor.parent; 62 63 }// ancestor 的平衡因子為 'L' 64 else if (ancestor.balanceFactor == 'L') { 65 // ancestor 的左子節點平衡因子為 '=' 66 if (ancestor.left.balanceFactor == '=') { 67 68 /* 刪除60 調整因子 繞50右旋 69 * 20 → → 20 → 20 70 * /R\ / \ /R\ 71 * 10 50 ← ancestor 10 50 ← 10 45 72 * /L /L\ / /L\ /L /R\ 73 * 5 45 60 5 45 60 5 35 50 ← 74 * /=\ /R\ /L 75 * 35 48 35 48 48 76 */ 77 ancestor.left.balanceFactor = 'R'; 78 ancestor.balanceFactor = 'L'; 79 rotateRight(ancestor); 80 heightHasDecreased = false; 81 82 }// ancestor 的左子節點平衡因子為 'L' 83 else if (ancestor.left.balanceFactor == 'L') { 84 85 /* 刪除60 調整因子 繞50右旋 下次循環調整20的因子 86 * 20 → → 20 → 20 ← p → ... 87 * /R\ / \ /R\ 88 * 10 50 ← ancestor 10 50 ← 10 45 89 * /L /L\ / /=\ /L /=\ 90 * 5 45 60 5 45 60 5 35 50 ← ancestor 91 * /L /= = 92 * 35 35 93 */ 94 Entry<E> p = ancestor.parent; 95 ancestor.balanceFactor = '='; 96 ancestor.left.balanceFactor = '='; 97 rotateRight(ancestor); 98 ancestor = p; 99 100 } // ancestor 的左子節點平衡因子為 'R' 101 else if (ancestor.left.balanceFactor == 'R') { 102 103 Entry<E> p = ancestor.parent; 104 105 // ancestor 的左子節點的右子節點的平衡因子為 'L' 106 if (ancestor.left.right.balanceFactor == 'L') { 107 108 /* 刪除60 調整因子 109 * 20 → 20 110 * /R\ / \ 111 * 10 50 ← ancestor 10 50 ← ancestor 112 * /L\ /L\ / \ /R\ 113 * 5 12 45 60 5 12 45 70 114 * /L /R\ R\ / /=\ 115 * 3 42 48 70 3 42 48 116 * /L /= 117 * 46 46 118 * 119 * 繞45左旋 繞50右旋 下次循環調整20的因子 120 * → 20 → 20 ← p → ... 121 * /R\ /R\ 122 * 10 50 ← 10 48 123 * /L\ /R\ /L\ /=\ 124 * 5 12 48 70 5 12 45 50 ← ancestor 125 * /L /= /L /=\ R\ 126 * 3 45 3 42 46 70 127 * /=\ 128 * 42 46 129 */ 130 ancestor.balanceFactor = 'R'; 131 ancestor.left.balanceFactor = '='; 132 133 }// ancestor 的左子節點的右子節點的平衡因子為 'R' 134 else if (ancestor.left.right.balanceFactor == 'R') { 135 136 /* 刪除60 調整因子 137 * 20 → 20 138 * /R\ / \ 139 * 10 50 ← ancestor 10 50 ← 140 * /L\ /L\ / \ /=\ 141 * 5 12 45 60 5 12 45 70 142 * /L /R\ R\ / /L\ 143 * 3 42 48 70 3 42 48 144 * R\ =\ 145 * 49 49 146 * 147 * 繞45左旋 繞50右旋 下次循環調整20的因子 148 * → 20 → 20 ← p → ... 149 * /R\ /R\ 150 * 10 50 ← 10 48 151 * /L\ /=\ /L\ /=\ 152 * 5 12 48 70 5 12 45 50 ← ancestor 153 * /L /=\ /L /L /=\ 154 * 3 45 49 3 42 49 70 155 * /L 156 * 42 157 */ 158 ancestor.balanceFactor = '='; 159 ancestor.left.balanceFactor = 'L'; 160 161 }// ancestor 的左子節點的右子節點的平衡因子為 '=' 162 else { 163 /* 刪除60 調整因子 164 * 20 → 20 165 * /R\ / \ 166 * 10 50 ← ancestor 10 50 ← 167 * /L\ /L\ / \ /=\ 168 * 5 12 45 60 5 12 45 70 169 * /L /R\ R\ / /=\ 170 * 3 42 48 70 3 42 48 171 * /=\ /=\ 172 * 46 49 46 49 173 * 174 * 繞45左旋 繞50右旋 下次循環調整20的因子 175 * → 20 → 20 ← p → ... 176 * /R\ /R\ 177 * 10 50 ← 10 48 178 * /L\ /=\ /L\ /=\ 179 * 5 12 48 70 5 12 45 50 ← ancestor 180 * /L /=\ /L /=\ /=\ 181 * 3 45 49 3 42 46 49 70 182 * /=\ 183 * 42 46 184 */ 185 ancestor.balanceFactor = '='; 186 ancestor.left.balanceFactor = '='; 187 188 } 189 ancestor.left.right.balanceFactor = '='; 190 rotateLeft(ancestor.left); 191 rotateRight(ancestor); 192 ancestor = p; 193 } 194 } 195 196 } 197 //從ancestor的左子樹中刪除節點,與上面是對稱的 198 else if (comp < 0) { 199 200 if (ancestor.balanceFactor == '=') { 201 202 ancestor.balanceFactor = 'R'; 203 heightHasDecreased = false; 204 } else if (ancestor.balanceFactor == 'L') { 205 206 ancestor.balanceFactor = '='; 207 ancestor = ancestor.parent; 208 209 } else if (ancestor.balanceFactor == 'R') { 210 211 if (ancestor.right.balanceFactor == '=') { 212 213 ancestor.balanceFactor = 'R'; 214 ancestor.right.balanceFactor = 'L'; 215 rotateLeft(ancestor); 216 heightHasDecreased = false; 217 218 } else if (ancestor.right.balanceFactor == 'R') { 219 220 Entry<E> p = ancestor.parent; 221 ancestor.balanceFactor = '='; 222 ancestor.right.balanceFactor = '='; 223 rotateLeft(ancestor); 224 ancestor = p; 225 226 } else if (ancestor.right.balanceFactor == 'L') { 227 228 Entry<E> p = ancestor.parent; 229 if (ancestor.right.left.balanceFactor == 'R') { 230 231 ancestor.balanceFactor = 'L'; 232 ancestor.right.balanceFactor = '='; 233 234 } else if (ancestor.right.left.balanceFactor == 'L') { 235 236 ancestor.balanceFactor = '='; 237 ancestor.right.balanceFactor = 'R'; 238 239 } else { 240 241 ancestor.balanceFactor = '='; 242 ancestor.right.balanceFactor = '='; 243 244 } 245 ancestor.right.left.balanceFactor = '='; 246 rotateRight(ancestor.right); 247 rotateLeft(ancestor); 248 ancestor = p; 249 250 } 251 } 252 } 253 } 254 } 255 256 public boolean contains(E o) { 257 258 Entry<E> e = root; 259 260 int comp; 261 262 while (e != null) { 263 264 comp = o.compareTo(e.elem); 265 if (comp == 0) 266 return true; 267 else if (comp < 0) 268 e = e.left; 269 else 270 e = e.right; 271 272 } 273 return false; 274 } 275 276 //驗證樹是否是平衡二叉樹 277 public boolean isAVL() { 278 279 return checkAVL(root); 280 281 } 282 283 /** 284 * 驗證指定的樹是否是平衡二叉樹 285 * @param p 286 * @return 287 */ 288 public static <E extends Comparable<E>> boolean checkAVL(Entry<E> p) { 289 290 if (p == null) 291 return true; 292 //左子樹與右子樹絕對值不能超過 1，并且左右子樹也是平衡二叉樹 293 return (Math.abs(h(p.left) - h(p.right)) <= 1 && checkAVL(p.left) && checkAVL(p.right)); 294 295 } 296 297 /** 298 * 求指定節點的高度 299 * @param <E> 300 * @param p 301 * @return 302 */ 303 protected static <E extends Comparable<E>> int h(Entry<E> p) { 304 305 if (p == null) 306 return -1; 307 return 1 + Math.max(h(p.left), h(p.right)); 308 } 309 310 /** 311 * 樹的高度 312 * @return 313 */ 314 public int height() { 315 316 return h(root); 317 318 } 319 320 //樹的高度非遞歸求法 321 public int heightIter() { 322 323 int height = -1; 324 for (Entry<E> temp = root; temp != null; height++) 325 if (temp.balanceFactor == 'L') 326 temp = temp.left; 327 else 328 temp = temp.right; 329 return height; 330 } 331 332 @Override 333 public Iterator<E> iterator() { 334 return new TreeIterator(); 335 } 336 337 @Override 338 public int size() { 339 return size; 340 } 341 }

測試：

1 package tree.avl; 2 3 import java.util.Iterator; 4 import java.util.Random; 5 6 public class AVLTreeTest { 7 public static void main(String[] args) { 8 AVLTree myTree = new AVLTree(); 9 Random random = new Random(); 10 System.out.print("隨機產生的節點為："); 11 int num = 0; 12 //直到樹的節點數為n止 13 while (myTree.size() < 10) { 14 num = new Integer(random.nextInt(100)); 15 myTree.add(num); 16 System.out.print(num + " "); 17 } 18 System.out.println(""); 19 if (myTree.isAVL()) { 20 System.out.println("這棵平衡二叉樹的總節點數：" + myTree.size()); 21 System.out.println("這棵平衡二叉樹的高度是：" + myTree.height()); 22 System.out.println("在樹中查找 " + num + " 節點:" 23 + myTree.contains(new Integer(num))); 24 System.out.println("在樹中查找 100 節點:" + myTree.contains(new Integer(100))); 25 System.out.print("中序遍歷："); 26 Iterator itr = myTree.iterator(); 27 while (itr.hasNext()) { 28 System.out.print(itr.next() + " "); 29 } 30 System.out.println(""); 31 32 myTree.remove(num); 33 System.out.print("刪除節點 " + num + " 后遍歷："); 34 itr = myTree.iterator(); 35 while (itr.hasNext()) { 36 System.out.print(itr.next() + " "); 37 } 38 System.out.println(""); 39 40 System.out.println("使用迭代器刪除所有節點"); 41 itr = myTree.iterator(); 42 while (itr.hasNext()) { 43 itr.next(); 44 itr.remove(); 45 } 46 System.out.println("刪除后樹的總節點數：" + myTree.size()); 47 } else { 48 System.out.println("failure"); 49 } 50 } 51 }

轉載于:https://www.cnblogs.com/jiangzhengjun/p/4289792.html

總結

以上是生活随笔為你收集整理的[数据结构与算法]平衡二叉树实现的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。