Presentation is loading. Please wait.

Presentation is loading. Please wait.

Binary Search Trees (Continued)

Similar presentations


Presentation on theme: "Binary Search Trees (Continued)"— Presentation transcript:

1 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

2 Study Project 3 Solution
Project 3 was due before class today Discuss solution

3 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

4 Balanced Binary Search Trees
Degenerate tree for a binary search tree 3 5 9 12 18 20

5 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

6 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

7 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 7 7 7 15 5 13 5 13 5 13 5 10 3 15 3 15 3 10 15 10 10 Initial Tree Step C 3 Step A Step B

8 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 10 10 10 3 10 5 13 5 13 5 13 7 13 3 15 3 15 3 7 15 7 7 Initial Tree Step A Step B Step C 15

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

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

11 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 Adel’son-Vel’ski 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 node’s balance factor is > +1 or < -1, the sub-tree with that node as root needs to be rebalanced

12 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

13 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

14 AVL Tree Right Rotation
Initial Tree After Add 1 Node is -2 Left Child is -1 7 (-1) 7 (-2) 5 (0) 9 (0) 5 (-1) 9 (0) 3 (0) 6 (0) 3 (-1) 6 (0) 1 (0)

15 AVL Tree Right Rotation
After Right Rotation 5 (0) 3 (-1) 7 (0) 1 (0) 6 (0) 9 (0)

16 AVL Tree Rightleft Rotation
Initial Tree After Remove 3 10 (1) 10 (2) Node is +2 Right Child is -1 5 (-1) 15 (-1) 5 (0) 15 (-1) Remove 3 (0) 13 (-1) 17 (0) 13 (-1) 17 (0) 11 (0) 11 (0)

17 AVL Tree Rightleft Rotation
After Right Rotation After Left Rotation 10 (2) 13 (0) 5 (0) 13 (1) 10 (0) 15 (1) 11 (0) 15 (1) 5 (0) 11 (0) 17 (0) 17 (0)

18 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

19 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

20 Introduction to Project 4
Study use of a stack data structure in the solution of the maze in the text In project 4, you will write different code to solve a maze via “wall-following” algorithm Your code will use a stack data structure to backtrack from blind alleys or dead ends The previous location visited is pushed onto the stack and is the first one to be retrieved if the code needs to backtrack

21 Introduction to Project 4
Maze with Wall-following (Left) Solution Alternatively, we could follow the right wall Enter Exit

22 UML Diagram for Project 4
Main Maze - path : Stack<Site> + main(String [ ] args) : void - iterate(start : Site, end : Site) : void - recurse(current:Site, end:Site) : bool - start : Site - end : Site + Maze( ) + getStart( ) : Site + getEnd ( ) : Site java.util.Stack Site - name : String - walls : Site [4] - direction : int + Site(name : String, left : Site, ahead : Site, right : Site) + toString( ) : String + next (direction : int) : Site + getDirection( ) : int

23 Introduction to Project 4
Because there is no reference back from a Site to the previous Site, your code must save the reference to the previous Site on an internal stack before moving forward You will write two different methods that can each solve the maze In “iterate”, your code will explicitly keep track of the path backwards on a stack In “recurse”, your code will implicitly keep track of the path back on the system stack


Download ppt "Binary Search Trees (Continued)"

Similar presentations


Ads by Google