Binary Search Trees (Continued)

Study Project 3 Solution Balanced Binary Search Trees Balancing Operations Implementing Balancing Operations
AVL Trees Red/Black Trees

Reading: L&C 10.1 10.9

Study Project 3 Solution

Project 3 was due before class today Discuss solution

Balanced Binary Search Trees

The balance of a binary search tree is important for obtaining its efficiency If we add 3, 5, 9, 12, 18, and 20 to a binary search tree, we get a degenerate tree This is less efficient than a singly linked list because our code needs to check the null left pointer at each level while traversing it Operations are O(n) instead of O(log n) We want our binary search trees balanced
3

Balanced Binary Search Trees

Degenerate tree for a binary search tree
3 5 9 12 18 20
4

Balancing Operations
Brute force balancing methods work but are unnecessarily time consuming We could use an in-order traversal of the tree and move everything out to an array Then, we could use a recursive method to insert the middle element of the array as the root and subdivide the array into two halves Eventually, we will rebuild a balanced tree
5

Balancing Operations
We prefer to use balancing operations after each add or remove element operation Semantics of balancing operations
Right rotation Left rotation Rightleft rotation Leftright rotation

Balancing Operations
Semantics of Right Rotation
A. Make the left child of the root the new root B. Make former root the right child of the new root C. Make right child of the former left child of the former root the new left child of the former root
13 7 5 3 10 Initial Tree 15 3 10 Step A 5 7 13 15 3 10 Step B Step C
7

7 5 13 15 3 5

7 13 10 15

Balancing Operations
Semantics of Left Rotation
A. Make the right child of the root the new root B. Make former root the left child of the new root C. Make left child of the former right child of the former root the new right child of the former root
5 3 7 Initial Tree 10 13 15 3 7 Step A 5 10 13 15 3 7 Step B Step C
8

10 5 13 15 3 5

10 13 7 15

Balancing Operations
Semantics of Rightleft Rotation
A. Right rotation around right child of root B. Left rotation around root
5 3 10 7 Initial Tree After Right Rotation 13 15 3 7 5 10 13 15 After Left Rotation 3 5 7 10 13 15

Balancing Operations
Semantics of Leftright Rotation
A. Left rotation around left child of root B. Right rotation around root
13 5 3 7 10 Initial Tree 3 After Left Rotation After Right Rotation 15 5 7 10 13 15 3 5 10 7 13 15

10

Implementing Balancing Operations

Now that we know how to rebalance the tree when needed, we must know how to detect that the tree needs to be rebalanced AVL trees (after Adelson-Velski and Landis) keep a balance factor attribute in each node that equals the height of the right sub-tree minus the height of the left sub-tree If a nodes balance factor is > +1 or < -1, the subtree with that node as root needs to be rebalanced

11

Implementing Balancing Operations

There are 2 ways for tree to become unbalanced
By insertion of a node By deletion of a node

Each time one of those occurs:

The balance factors must be updated The balance of the tree must be checked from the point of change up to and including the root

It is best for AVL trees to have a parent reference in each child node to backtrack up the tree easily We can now detect the need for making any one of the balancing rotations we have already studied
12

Implementing Balancing Operations

If the balance factor of a node is -2
If the balance factor of its left child is -1
Perform a right rotation

If the balance factor of its left child is +1

Perform a leftright rotation

If the balance factor of a node is +2

If the balance factor of its right child is +1
Perform a left rotation

If the balance factor of its right child is -1

Perform a rightleft rotation
13

AVL Tree Right Rotation

Initial Tree 7 (-1) Node is -2 Left Child is -1 After Add 1 7 (-2)

5 (0)

9 (0)

5 (-1)

9 (0)

3 (0)

6 (0)

3 (-1)

6 (0)

1 (0)
14

AVL Tree Right Rotation

After Right Rotation 5 (0)

3 (-1)

7 (0)

1 (0)

6 (0)

9 (0)

15

AVL Tree Rightleft Rotation

Initial Tree 10 (1) After Remove 3 10 (2) Node is +2 Right Child is -1

Remove

5 (-1)

15 (-1)

5 (0)

15 (-1)

3 (0)

13 (-1)

17 (0)

13 (-1)

17 (0)

11 (0)

11 (0)
16

AVL Tree Rightleft Rotation

After Right Rotation 10 (2) After Left Rotation 13 (0)

5 (0)

13 (1)

10 (0)

15 (1)

11 (0)

15 (1)

5 (0)

11 (0)

17 (0)

17 (0)
17

Implementing Balancing Operations

There is another way to detect the need to rebalance a binary search tree Red/Black Trees (developed by Bayer and extended by Guibas and Sedgewick) keep a color red or black for each node in the tree
The root is black All children of a red node are black Every path from the root to a leaf contains the same number of black nodes
18

Implementing Balancing Operations

As with AVL trees:
The only time we need to rebalance and recolor is after the insertion or deletion of a node It is best for Red/Black trees to have a parent reference in each child node to backtrack up the tree easily

The maximum height of a Red/Black tree is roughly 2*log n (not as well controlled as an AVL tree), but traversal of the longest path is still O(log n) The rest of this topic is left to the student to study
19

Introduction to Project 4
Study use of these Java Collections APIs
HashMap<K,V> Map.Entry<K,V> PriorityQueue<T>

Study the concept of Huffman coding based on character frequency

A tree with the most frequent characters in leaves closer to the root Following left child adds a 0 to the code Following right child adds a 1 to the code
20

Sample Huffman Coding Tree

Symbol/Frequency

E / 0.40

Binary Code Sequence (Read right to left) 0

T / 0.35

10 1

I / 0.20

110
11 111

Others / 0.05

An E which occurs 40% of the time takes only 1 binary digit Zero A T which occurs 35% of the time takes only 2 binary digits One and Zero An I which occurs 20% of the time takes only 2 binary digits One and One All other characters which only occur 5% of the time take 3 or more digits

UML Diagram for Project 4

HuffmanTree - encodeTable : HashMap - decodeTable : HashMap - compressionRatio : double + main(String [ ] args) : void + HuffmanTree (message : String) + encode (message : String) : String + decode (message : String) : String + getCompressionRatio (void) : double <<Interface>> Comparable<HuffmanNode>

HuffmanNode - value : String - frequency : int - zero : HuffmanNode - one : HuffmanNode + HuffmanNode (message : String) + compareTo(that : HuffmanNode) : int + toString(void) : String + getValue(void) : String + getFrequency (void) : int + increment (void) : void + getZero (void) : HuffmanNode + getOne (void) : HuffmanNode

java.util.HashMap java.util.Set java.util.Map.Entry java.util.PriorityQueue