When a BST becomes badly unbalanced, the search behavior can degenerate to that of a sorted linked list, O(N).

Transcription

1 Balanced Binary Trees Binary searc trees provide O(log N) searc times provided tat te nodes are distributed in a reasonably balanced manner. Unfortunately, tat is not always te case and performing a sequence of deletions and insertions can often exacerbate te problem. Wen a BST becomes badly unbalanced, te searc beavior can degenerate to tat of a sorted linked list, O(N). Tere are a number of strategies for dealing wit tis problem; most involve adding some sort of restructuring to te insertdelete algoritms. Tat can be effective only if te restructuring reduces te average dept of a node from te of te BST, and if te cost of te restructuring is, on average, O(log N). We will examine one suc restructuring algoritm AVL tree*: a binary searc tree in wic te eigts of te left and rigt subtrees of te differ by at most, and in wic te left and rigt subtrees are temselves AVL trees. Eac AVL tree node as an associated balance factor indicating te relative eigts of its subtrees (left-iger, equal, rigt-iger). Normally, tis adds one data element to eac tree node and an enumerated type is used. How effective is tis? Te eigt of an AVL tree wit N nodes never exceeds.44 log N and is typically muc closer to log N. *G. M. Adelson-Velskii and E. M. Landis, 96.

2 Examples Tis is an AVL tree......and tis is not. Unbalance from Insertion Consider inserting te value 45 into te AVL tree: Te result would be unbalanced at te node containing 5: 5 50 Te unbalance is repaired by applying one of two types of rotation to te unbalanced subtree 0 45

3 Rebalancing via Subtree Restructuring 5 Te subtree ed at 5 is rigt-iger We restructure te subtree, resulting in a balanced subtree: Te transformation is relatively simple, requiring only a few operations, and results in a subtree tat as equal balance. AVL Insertion Case: rigt-iger 6 Tere are two unbalance cases to consider, eac defined by te state of te subtree tat just received a new node. For simplicity, assume for now tat te insertion was to te rigt subtree (of te subtree). Let be te of te newly unbalanced subtree, and suppose tat its rigt subtree is now rigt-iger: rigt In tis case, te subtree ed at rigt was previously equally balanced (wy?) and te subtree ed at was previously rigtiger (wy?). T Te eigt labels follow from tose observations. T + T Balance can be restored by rotating te values so tat rigt becomes te subtree node and becomes te left cild.

4 AVL Left Rotation 7 Te manipulation just described is known as a left rotation and te result is: rigt rigt T T + T Overall eigt of eac subtree is now te same. T T T Tat covers te case were te rigt subtree as become rigt-iger te case were te left subtree as become left-iger is analogous and solved by a rigt rotation. AVL Insertion Case: left-iger Now suppose tat te rigt subtree as become left-iger: 8 T rigt-left? rigt Te insertion occurred in te left subtree of te rigt subtree of. In tis case, te left subtree of te rigt subtree (ed at rigt-left) may be eiter left-iger or rigt-iger, but not balanced (wy?). T or T T 4 Surprisingly (peraps), tis case is more difficult. Te unbalance cannot be removed by performing a single left or rigt rotation.

5 AVL Double Rotation 9 Applying a single rigt rotation to te subtree ed at rigt produces rigt rigt-left rigt-left?? rigt T 4 T T or T T T 4 a subtree ed at rigt-left tat is now rigt-iger AVL Double Rotation 0 Now, applying a single left rotation to te subtree ed at produces rigt-left? Balance factors ere depend on original balance factor of rigt-left. rigt? rigt-left? rigt T T T 4 T T T T 4 or a balanced subtree. Te case were te left subtree of is rigt-iger is andled similarly (by a double rotation).

6 AVL Node Class Interface An AVL tree implementation can be derived from te BinNodeT and BST classes seen earlier owever, te AVLNode class must add a data member for te balance factor, and a mutator member function for te balance factor: enum BFactor {LEFTHI, RIGHTHI, EQUALHT, DBLRIGHTHI, DBLLEFTHI, BALUNKNOWN; template <typename T> class AVLNode { public: T Element; AVLNode<T>* Left; AVLNode<T>* Rigt; AVLNode<T>* Parent; BFactor Balance; ; AVLNode(); AVLNode(const T& Elem, AVLNode<T>* L = NULL, AVLNode<T>* R = NULL, AVLNode<T>* P = NULL); BFactor adjustbalance(bfactor Grew); bool isleaf() const; ~AVLNode(); Because of tat, using deriving te AVLNode from te more general BSTNode creates more problems tan it solves, and so ineritance is not used in tis implementation. AVL Tree Class Interface Te AVL tree public interface includes: template <typename T> class AVL { public: AVL(); AVL(const AVL<T>& Source); AVL<T>& operator=(const AVL<T>& Source); ~AVL(); T* const Insert(const T& Elem); bool Delete(const T& Elem); T* const Find(const T& Elem); void Clear(); void Display(ostream& Out) const; Iterator declarations omitted to save space... IOiterator ifind(const T& D); return access to D continues...

7 AVL Tree Class Interface Te AVL tree private section includes: continues... private: AVLNode<T>* Root; private elper functions omitted... string BFtoString(BFactor BF) const; used in Display() fn ; void RigtBalance(AVLNode<T>* sroot); re-balance managers used by void LeftBalance(AVLNode<T>* sroot); used by insertdelete fns void RotateLeft(AVLNode<T>* sroot); rotation functions used by void RotateRigt(AVLNode<T>* sroot); used by managers AVL Left Rotation Implementation 4 template <typename T> void AVL<T>::RotateLeft(AVLNode<T>* sroot) { if ( (sroot == NULL) (sroot->rigt == NULL) ) return; AVLNode<T>* Temp = new AVLNode<T>(sRoot->Element); Temp->Left = sroot->left; sroot->left = Temp; Temp->Rigt = sroot->rigt->left; AVLNode<T>* todelete = sroot->rigt; sroot->element = todelete->element; sroot->rigt = todelete->rigt; sroot->balance = todelete->balance; delete todelete;

8 AVL Rigt Balance Implementation Te implementation uses two ig-level functions to manage te rebalancing, one for wen te imbalance is to te rigt and one for wen it is to te left. 5 RigtBalance() would be called wen a condition of double-rigt-ig as been detected at a node following an insertion: template <typename T> void AVL<T>::RigtBalance(AVLNode<T>* sroot) { if ( (sroot == NULL) (sroot->rigt == NULL) ) return; AVLNode<T>* rigtsubtreeroot = sroot->rigt; switc ( sroot->rigt->balance ) { case RIGHTHI: sroot->balance = EQUALHT; rigtsubtreeroot->balance = EQUALHT; RotateLeft(sRoot); break; continues... AVL Rigt Balance Implementation 6 continued... case LEFTHI: AVLNode<T>* leftsubtreerigtsubtree = rigtsubtreeroot->left; switc ( leftsubtreerigtsubtree->balance ) { code to reset balance factors... ; leftsubtreerigtsubtree->balance = EQUALHT; RotateRigt(rigtSubTreeRoot); RotateLeft(sRoot); break;

9 AVL Insert Implementation As usual, insertion involves a relatively simple public "stub" and a recursive elper. 7 template <typename T> T* const AVL<T>::Insert(const T& Elem) { bool Taller = false; return InsertHelper(Elem, Root, NULL, Taller); template <typename T> T* const AVL<T>::InsertHelper(const T& Elem, AVLNode<T>*& sroot, AVLNode<T>* Par, bool& Taller) { if ( sroot == NULL ) { found te rigt location sroot = new AVLNode<T>(Elem); sroot->parent = Par; Taller = true; return &(sroot->element); continues... Tis leaves compensating for te effect of te insertion to be andled wen te recursion backs out. AVL Insert Helper: Descent and Rebalance 8 continued... if ( Elem < (sroot->element) ) { T* insertresult = InsertHelper(Elem, sroot->left, sroot, Taller); if ( Taller ) { left subtree just got taller BFactor srootbalance = sroot->adjustbalance(lefthi); if ( srootbalance == EQUALHT ) { Taller = false; else if ( srootbalance == LEFTHI ) { Taller = true; else if ( srootbalance == DBLLEFTHI ) { Taller = false; LeftBalance( sroot ); return insertresult; else {... continues to andle descent down rigt subtree...

10 Unbalance from Deletion 9 Deleting a node from an AVL tree can also create an imbalance tat must be corrected. Te effects of deletion are potentially more complex tan tose of insertion. Te basic idea remains te same: delete te node, track canges in balance factors as te recursion backs out, and apply rotations as needed to restore AVL balance at eac node along te pat followed down during te deletion. However, rebalancing after a deletion may require applying single or double rotations at more tan one point along tat pat. As usual, tere are cases Here, we will make te following assumptions: - te lowest imbalance occurs at te node (a subtree ) - te deletion occurred in te left subtree of AVL Deletion Case: rigt-iger 0 Suppose we ave te subtree on te left prior to deletion and tat on te rigt after deletion: rigt rigt rigt Note: "rigt-iger" refers to te balance factor of te of te rigt subtree (labeled rigt ere). Ten a single left rotation at will rebalance te subtree.

11 AVL Deletion Case: equal-eigt Suppose we te rigt subtree as balance factor equal-eigt: rigt Again, a single left rotation at will rebalance te subtree. rigt Te difference is te resulting balance factor at te old subtree node,, wic depends upon te original balance factor of te node rigt. AVL Deletion Case: left-iger If te rigt subtree was left-iger, we ave te following situation: rigt-left? or -? rigt 4 Deleting a node from te left subtree of now will cause to become double rigt iger. As you sould expect, te resulting imbalance can be cured by first applying a rigt rotation at te node rigt, and ten applying a left rotation at te node. However, we must be careful because te balance factors will depend upon te original balance factor at te node labeled rigt-left

12 AVL Deletion Case: left-iger, left-iger If te rigt-left subtree was also left-iger, we obtain: rigt-left rigt-left rigt 4 rigt AVL Deletion Case: left-iger, rigt-iger If te rigt-left subtree was rigt-iger, we obtain: 4 rigt-left rigt-left rigt 4 rigt And, finally, if te rigt-left subtree was equal-eigt, we'd obtain a tree were all tree of te labeled nodes ave equal-eigt.

13 AVL Deletion Cases: Summary 5 We ave considered a number of distinct deletion cases, assuming tat te deletion occurred in te left subtree of te imbalanced node. Tere are an equal number of entirely similar, symmetric cases for te assumption te deletion was in te rigt subtree of te imbalanced node. Drawing diagrams elps Tis discussion also as some logical implications for ow insertion is andled in an AVL tree. Te determination of te balance factors in te tree, following te rotations, involves similar logic in bot cases. Implementing AVL Deletion 6 Turning te previous discussion into an implementation involves a considerable amount of work. At te top level, te public delete function must take into account weter te deletion sortened eiter subtree of te tree node. If tat was te case, ten it may be necessary to perform a rotation at te tree itself. Tus, te elper function(s) must be recursive and must indicate weter a subtree was sortened; tis may be accomplised by use of a bool parameter, as was done for te insertion functions. Deletion of te tree node itself is a special case, and sould take into account weter te tree node ad more tan one subtree. If not, te pointer sould simply be retargeted to te appropriate subtree and no imbalance occurs. If te tree node as two subtrees, its value sould be swapped wit te minimum value in te rigt subtree and ten te corresponding node sould be deleted from te rigt subtree.

14 Testing 7 In testing te AVL implementation, I found a few useful ideas: - Test wit small cases first, and vary tem to cover all te different scenarios you can tink of. - Work out te solutions manually as well. If you don't understand ow to solve te problem by and, you'll NEVER program a correct solution. - Test insertion first, torougly. - Ten build an initial, correct AVL tree and test deletion, torougly. - Ten test alternating combinations of insertions and deletions. - Modify your tree print function to sow te balance factors: c d- e - j- k- o s-