Understanding AVL Trees: Height-Balanced Binary Search Trees Explained
This article delves into AVL Trees, a type of height-balanced binary search tree. It presents a clear definition of what it means for a tree to be height-balanced, detailing how balance factors play a critical role in maintaining this property. The text explains insertion processes, rotation types for balance restoration, and even includes sample numbers to illustrate the construction of an AVL tree. With practical examples and definitions, this resource is perfect for anyone interested in data structures and algorithms.
Understanding AVL Trees: Height-Balanced Binary Search Trees Explained
E N D
Presentation Transcript
2008/01/06 資料結構課後輔導(AVL Trees)
Height-Balanced • Definition • An empty tree is height-balanced. • If T is nonempty binary tree with TL and TR as its left and right subtrees respectively. • T is height-balanced iff • TL and TR are height-balanced, and • |hL-hR|≦1 where hL and hR are heights of TL and TR, respectively.
Examples 5 6 4 8 4 9 1 7 9 2 5 8 11 2 6 1 3 7 10 12 12 11 3 10 Not height-balanced Height-balanced
Balance Factor • Definition: • For every node T, define its balance factor, BF(T), as BF(T) = hL - hR where hL and hR are the heights of the left and right subtrees of T. • BF(T) for any node T in an AVL tree is –1, 0, or 1.
Balance Factors for an AVL Tree -1 1 1 -1 0 1 0 0 -1 0 0 0 0
Construction of an AVL Tree • Consider to insert the following numbers: • 8, 9, 10, 2, 1, 5, 3, 6, 4, 7, 11, 12 0 -1 8 8 0 9 Insert 8 Insert 9
Consider the nearest parent A with bf = ±2 -2 8 8 0 RR 9 -1 9 9 0 0 8 10 0 insert in the right subtree of the right subtree of A 10 Insert 10
1 9 1 0 8 10 0 2 Insert 2
2 Consider the nearest parent A with bf = ±2 9 1 2 0 9 8 8 10 0 0 1 LL 2 10 2 2 0 0 0 1 8 1 insert in the left subtree of the left subtree of A Insert 1
Consider the nearest parent A with bf = ±2 0 2 8 9 9 0 -1 -1 0 LR 2 9 2 10 0 0 0 0 1 1 5 10 1 8 8 insert in the right subtree of the left subtree of A 0 5 Insert 5
1 1 8 8 -1 -1 -1 -1 2 9 2 9 0 0 0 0 1 0 1 1 5 10 5 10 0 0 0 3 3 6 Insert 3 Insert 6
Consider the nearest parent A with bf = ±2 1 2 8 8 0 -1 -2 -1 3 9 2 2 9 0 1 0 0 0 RL 1 1 2 5 10 5 10 0 0 0 -1 0 1 4 6 3 3 6 insert in the left subtree of the right subtree of A 0 4 Insert 4
0 2 5 8 8 0 -1 -1 1 3 9 3 8 LR 0 1 -1 -1 1 0 -1 2 5 5 10 9 2 4 6 0 0 0 0 0 -1 1 1 7 10 4 6 0 7 Insert 7
0 5 0 1 3 8 0 -1 1 0 -1 5 10 2 4 6 0 -1 0 0 0 1 1 3 7 9 11 8 -2 1 0 -1 RR 9 9 2 4 6 0 0 -1 1 7 10 10 0 11 Insert 11
-1 5 -1 1 8 3 1 0 -1 -1 10 2 6 4 0 0 -1 0 1 7 9 11 0 12 Insert 12
Rotation Types (1) • Suppose Y is the new node. • LL: Y is inserted in the left subtree of the left subtree of A. A B B LL A TBR TA TBR TBL TBL TA Height (TA) + 2 = Height(TBR) + 1 => Height (TA) + 1 = Height(TBR) Height (TBL) + 1 = Height(TBR) =>Height (TBR) = Height(TA)
Rotation Types (2) • LR: Y is inserted in the right subtree of the left subtree of A A C LR TA B B A C TCL TCR TA TCL TCR
Rotation Types (3) • RR: Y is inserted in the right subtree of the right subtree of A. A B RR B TA A C C TB TA TB
Rotation Types (4) • RL: Y is inserted in the left subtree of the right subtree of A C A RL A B TA B C TA TCL TCR TCL TCR
The Class Definition of AVL Tree class AvlNode { public: AvlNode(int k) {data = k; bf = 0; leftChild = NULL; rightChild = NULL; } private: int data; int bf; AvlNode *leftChild, *rightChild; }; class AVL { public: AVL() : root(0) {}; bool Search(int key); bool Insert(int key); bool Delete(int key); private: AvlNode *root; }; Store the value of balance factor of the node
Phase 1 bool AVL::Insert(int key) { if (!root) { root = new AvlNode(key); return true; } //Phase 1: locate insertion point for key AvlNode *a = 0, //most recent node with bf = ± 1 *pa = 0, //parent of a *p = root, //p moves through the tree *pp = 0; //parent of p
while (p) { if (p->bf != 0) { a = p; pa = pp; } if (k > p->key) { pp = p; p = p->rightChild; } else if (k < p->key) { pp = p; p = p->leftChild; } else return false; }
Phase 2 //Phase 2: Insert and rebalance //k is not in the tree and may be inserted as the appropriate child of pp. AvlNode *y = new AvlNode(k); if (k < pp->key) pp->leftChild = y; //insert as left Child else pp->rightChild = y; //insert as right Child
int d; AvlNode *b, //child of a *c; //child of b if (a == NULL) { p = root; d = (k > p->key)? -1 : 1; } else if (k > a->key) { b = p = a->rightChild; d = -1; } else { b = p = a->leftChild; d = 1; } while (p != y) { if (k > p->key) { p->bf = -1; p = p->rightChild; } else { p->bf = 1; p = p->leftChild; } } 1 pa 8 • Adjust balance factors of nodes on path from a to pp. d=-1 -1 a -1 2 9 b 0 0 0 p 1 5 10 1 0 0 3 6 -1 p y 4 p
Rotation - LL if (a == NULL) return true; else if (a->bf==0 || a->bf+d == 0) { a->bf += d; return true; } if (d == 1) //left imbalance { if (b->bf == 1) //rotation type LL { a->leftChild = b->rightChild; b->rightChild = a; a->bf = 0; b->bf = 0; } a b A B b a B C A TA C TB TB TA
Rotation - LR A else //rotation type LR { c = b->rightChild; b->rightChild = c->leftChild; a->leftChild = c->rightChild; c->leftChild = b; c->rightChild = a; switch (c->bf) { case 1: a->bf = -1; b->bf = 0; break; case -1: b->bf = 1; a->bf = 0; break; case 0: b->bf = 0; b->bf = 0; break; } c->bf = 0; b = c; //b is the new root } } TA B a C C TCL TCR b B A c c TCL TCR TA b a
9 8 8 10 2 2 1 else { //right imbalance. This is symmetric to left imbalance } if (pa == NULL) root = b; else if (a == pa->leftChild) pa->leftChild = b; else pa->rightChild = b; return true; } 9 2 10 pa 1 8 pa a b b LL a
