CSE 373 Lecture 7: More on Search Trees Array Implementation of Trees

✦ Today’s Topics: ✦ Used mostly for complete binary trees

➭ A complete tree has no gaps when you scan 94
➭ Array Implementation of Trees the nodes left-to-right, top-to-bottom
➭ Lazy Deletion
➭ Run Time Analysis of Binary Search Tree Operations ✦ Idea: Use left-to-right scan to impose a
➭ AVL Trees linear order on the tree nodes 10 97
➭ Splay Trees ✦ Implementation:
➭ Children of A[i] = A[2i+1], A[2i+2]
✦ Covered in Chapter 4 of the text ➭ Use a default value to indicate empty node 5 24
➭ Exercise: Draw array for the tree shown

✦ Why is this implementation inefficient

for non-complete trees?

R. Rao, CSE 373 Lecture 1 1 R. Rao, CSE 373 Lecture 1 2

Pointer Implementation: Delete Operation Lazy Deletion

✦ Problem: When you delete a node, 94 ✦ A “lazy” operation is one that puts off work as much as
what do you replace it by? possible in the hope that a future operation will make the
current operation unnecessary
✦ Solution:
1. If it has no children, by NULL 10 97 ✦ Idea: Mark node as deleted; no need to reorganize tree
2. If it has 1 child, by that child ➭ Skip marked nodes during Find or Insert
3. If it has 2 children, by the node with ➭ Reorganize tree only when number of marked nodes exceeds a
percentage of real nodes (e.g. 50%)
the smallest value in its right subtree, ➭ Constant time penalty due to marked nodes – depth increases only by
(or largest value in left subtree) 5 24
a constant amount if 50% are marked undeleted nodes
Recursively delete node being used in 2 and 3
✦ Modify Insert to make use of marked nodes whenever
✦ Worst case: Recursion propagates all possible e.g. when deleted value is re-inserted
the way to a leaf node – time is 11
O(depth of tree) ✦ Can also use lazy deletion for Lists

R. Rao, CSE 373 Lecture 1 17 3 R. Rao, CSE 373 Lecture 1 4

Run Time Analysis of Binary Search Trees Balancing Trees
✦ All BST operations (except MakeEmpty) are O(d), where d ✦ Many algorithms exist for keeping trees 6
is tree depth balanced
➭ MakeEmpty takes O(N) for a tree with N nodes – frees all nodes ➭ Adelson-Velskii and Landis (AVL) trees (1962) 4 9
✦ From last time, we know: log N ≤ d ≤ N-1 for a binary tree ➭ Splay trees and other self-adjusting trees (1978)
with N nodes ➭ B-trees and other multiway search trees (1972) 1 5 8
➭ What is the best case tree? What is the worst case tree?
✦ First try at balancing trees: Perfect balance Insert 2 &
✦ So, best case running time of BST operations is O(log N) ➭ Want a complete tree after every operation complete
➭ In fact, average case is also O(log N) – see text ➭ Too expensive E.g. Insert 2
➭ Need a looser constraint…
5
✦ Worst case running time is O(N)
➭ E.g. What happens when you Insert elements in ascending order? 2 8
➧ Insert: 2, 4, 6, 8, 10, 12 into an empty BST
➭ Problem: Lack of “balance”: compare depths of left and right subtree
1 4 6 9
R. Rao, CSE 373 Lecture 1 5 R. Rao, CSE 373 Lecture 1 6

AVL Trees Insert and Rotation in AVL Trees

✦ AVL trees are height-balanced binary 6 2 ✦ Insert operation may cause balance factor to become 2 or –2
search trees 2
for some node on the path from insertion point to root node
✦ Balance factor of a node = height(left 4 9 ➭ After Insert, back up to root updating heights
1 1 1 ➭ If difference = 2 or –2, adjust tree by rotation around deepest such
subtree) - height(right subtree) node
1 5 8
✦ An AVL tree has balance factor of 1, 0, or ➭ Example:
–1 at every node 6 3 6 4
2 6 2 1 1
➭ For every node, heights of left and right 1
subtree differ by no more than 1 6 1 9 4
2 4 4 1 6
➭ Store current heights in each node 1 2 Insert 1 1 Rotate
4 9
✦ Can prove: Height is O(log N) 1 1 1 7 1
All operations (e.g. Find) are O(log N) 1
except Insert (assume lazy deletion) 1 5
8
R. Rao, CSE 373 Lecture 1 7 R. Rao, CSE 373 Lecture 1 8
Insertion: Another Example Insertion: Example 1 (Outside case)

BF = 1 BF = ?
BF = 1 BF = 0 BF = ?
BF = 0 BF = 0
BF = ? BF = 0
BF = 0 BF = 0

BF = 0 BF = 0 BF = ?
BF = 0

BF = 0
Tree before insertion (BF = Balance Factor) Tree after insertion

R. Rao, CSE 373 Lecture 1 9 R. Rao, CSE 373 Lecture 1 10

Insertion: Example 2 (Inside case) Insertions in AVL Trees

Let the node that needs rebalancing be α.

There are 4 cases:

BF =
Outside Cases (require single rotation) :
BF = BF =
1. Insertion into left subtree of left child of α.
BF = BF = 2. Insertion into right subtree of right child of α.
BF = BF =
Inside Cases (require double rotation) :
BF = BF = 3. Insertion into right subtree of left child of α.
BF = 0
4. Insertion into left subtree of right child of α.
Tree after insertion The rebalancing is performed through four separate rotation
algorithms – on board examples. See text for details.
R. Rao, CSE 373 Lecture 1 11 R. Rao, CSE 373 Lecture 1 12