CSE 373: Data Structures and Algorithms

Lecture 9: Binary Search Trees

Instructor: Lilian de Greef

Quarter: Summer 2017
Today
• Announcements
• Binary Trees
• Height
• Traversals
• Binary Search Trees
• Definition
• find
• insert
• delete
• buildTree
Announcements
• Change to office hours for just this week
• Tuesday’s “office” office hours / private office hours
• 12:00pm – 12:30pm
• (not at 1:30pm!)
• Dorothy and I trading 2:00pm - 3:00pm office hours this week
• Same time and location

• Homework 1 Statistics
• Mean: 39.7/50 (+1 extra credit)
• Median: 42.5/50 (+0 extra credit)
• Max: 49/50 (+1) or 47/50 (+4)
• Standard Deviation: 10.18
Reminder: Tree terminology
Node / Vertex
A Root

B C
Left subtree
Right subtree
D E F G

Edges H I Leaves

J K L M N
Binary Trees
• Binary tree: Each node has at most 2 children (branching factor 2)
• Binary tree is
• A root (with data)
• A left subtree (may be empty)
• A right subtree (may be empty)

• Special Cases:
(Last week’s practice) What does the following method do?
int height(Node root){
if (root == null),
return -1;
return 1 + max(height(root.left),
height(root.right);
}

A. It calculates the number of nodes in the tree.

B. It calculates the depth of the nodes.
C. It calculates the height of the tree.
D. It calculates the number of leaves in the tree.
Binary Trees: Some Numbers
Recall: height of a tree = longest path from root to leaf (count edges)

For binary tree of height h:

• max # of leaves:
• max # of nodes:

• min # of leaves:
• min # of nodes:

For n nodes, the min height (best-case) is

the max height (worst-case) is

Tree Traversals
A traversal is an order for visiting all the nodes of a tree

• Pre-order: root, left subtree, right subtree A

B C
• In-order: left subtree, root, right subtree

D E F
• Post-order: left subtree, right subtree, root
G
Tree Traversals: Practice
Which one makes sense for evaluating this expression tree?

• Pre-order: root, left subtree, right subtree

+

• In-order: left subtree, root, right subtree * 5

• Post-order: left subtree, right subtree, root 2 4

 Binary Search Tree (BST) Data Structure
• Structure property (binary tree) 8
• Each node has £ 2 children
• Result: keeps operations simple
5 11
• Order property
2 6 10 12

4 7 9 14
• Result: straight-forward to find any given value
13

A binary search tree is a type of binary tree

(but not all binary trees are binary search trees!)
Practice: are these BSTs?

5 8

4 8 5 11

1 7 11 2 7 6 10 18

3 4 15 20

21
How do we find(value) in BST’s?

12

5 15

2 9 20

7 10 17 30
find in BST: Recursive Version
Data find(Data value, Node root){
if(root == null)
12 return null;
if(key < root.value)
return find(value, root.left);
if(key > root.value)
5 15 return find(value, root.right);
return root.value;
}
2 9 20
What is the running time?
7 10 17 30
find in BST: Iterative Version

12 Data find(Object value, Node root){

while(root != null
&& root.value != value) {
if (value < root.value)
5 15 root = root.left;
else (value > root.value)
root = root.right;
}
2 9 20 if(root == null)
return null;
return root.value;
7 10 17 30 }
Other BST “Finding” Operations
findMin: Find minimum node 12

5 15

findMax: Find maximum node 2 9 20

7 10 17 30
insert in BST
12 insert(13)
insert(8)
insert(31)
5 15

2 9 20

7 10 17 30 Worst-case running time:

Practice with insert, primer for delete
Start with an empty tree. Insert the following values, in the given order:
14, 2, 5, 20, 42, 1, 4, 16
Then, changing as few nodes as possible, delete the following in order:
42, 14
What would the root of the resulting tree be?
A. 2
B. 4
C. 5
D. 16
(Extra space for scratch work / notes)
delete in BST
• Why might delete be harder than insert?

• Basic idea:

• Three potential cases to fix:

delete case: Leaf

delete(17) 12

5 15

2 9 20

7 10 17 30
delete case: One Child

delete(15) 12

5 15

2 9 20

7 10 30
delete case: Two Children

delete(5) 12

What can we 5
replace 5 with?
2 9 20

7 10 30
delete case: Two Children
What can we replace the node with?

Options:
delete case: Two Children (example #2)

delete(23) 12

5 23

2 9 18 30

7 10 15 19 25 32
Practice with insert, primer for delete
Changing as few nodes as possible, delete the following in order:
42, 14
14

2 20

1 5 16 42

4
delete through Lazy Deletion
• Lazy deletion can work well for a BST
• Simpler
• Can do “real deletions” later as a batch
• Some inserts can just “undelete” a tree node

• But
• Can waste space and slow down find operations
• Make some operations more complicated:
• e.g., findMin and findMax?
buildTree for BST
Let’s consider buildTree (insert values starting from an empty tree)

Insert values 1, 2, 3, 4, 5, 6, 7, 8, 9 into an empty BST

• If inserted in given order,

what is the tree?

• What big-O runtime for

buildTree on this sorted input?

• Is inserting in the reverse order any better?

buildTree for BST
Insert values 1, 2, 3, 4, 5, 6, 7, 8, 9 into an empty BST
What we if could somehow re-arrange them
• median first, then left median, right median, etc.
5, 3, 7, 2, 1, 4, 8, 6, 9

• What tree does that give us?

• What big-O runtime?