COS 212

BST: Depth-First
Traversals, Insertion &
Deletion
Binary Search Tree (BST)
 An ordered binary tree (a.k.a. binary search tree)
is a binary tree where for each node n:
 Values stored in the left subtree of a node n are less than the
value stored in n
 Values stored in the right subtree of a node n are greater
than the value stored in n
 Traversing a tree: breadth-first VS depth-
first
8
5 6 A

y
3 7 1 D

z
1 6 9 C E
Depth-first Traversal
 Depth-first:
 Traverse as deep as possible for each child before going
to the next child.
 Go through the tree branch-by-branch.

3 7

1 6 9

 Question: when traversing a tree, what do we output

first: the parent or the children?
 Three DF traversal types: preorder, inorder, postorder
Depth-first Traversal
 Preorder traversal: Parent first
 Parent is visited first, then its children are visited
public void preorder() {
preorder(root);
5 }
protected void
preorder(BSTNode<T> p)
3 7 {
if (p != null) {
visit(p);
preorder(p.left);
1 6 9
preorder(p.right);
}
}

5 3 1 7 6 9
Depth-first Traversal
 Inorder traversal: Left, Parent, Right
 Left child is visited first, then parent, then the right child

public void inorder() {

5 inorder(root);
}
protected void
inorder(BSTNode<T> p)
3 7 {
if (p != null) {
inorder(p.left);
visit(p);
1 6 9
inorder(p.right);
}
}

1 3 5 6 7 9
Depth-first Traversal
 Postorder traversal: Children first
 Children are visited first, then the parent
public void postorder()
{
5 postorder(root);
}
protected void
postorder(BSTNode<T> p)
3 7 {
if (p != null) {
postorder(p.left);
1 6 9
postorder(p.right);
visit(p);
}
}

1 3 6 9 7 5
Depth-first Traversal
protected void preorder(BSTNode<T> Traversal
p) algorithms are
{ elegant. But
if (p != null) { are they
visit(p);
preorder(p.left); efficient?
preorder(p.right);
}
} protected void inorder(BSTNode<T>
p)
{
if (p != null) {
inorder(p.left);
visit(p);
inorder(p.right);
}
}
protected void
postorder(BSTNode<T> p)
{
if (p != null) {
postorder(p.left); Space & time
postorder(p.right); efficiency: O(n)
visit(p);
}
}
Inserting a node into BST
 We know how to search & traverse the BST
 How do we add new nodes?
 To maintain BST structure, apply the search
algorithm to the BST, and insert the node at the
empty leaf location where the algorithm takes you
 Insert 4 into the following tree:

5 5

3 7 3 7

1 6 9 1 4 6 9
Inserting a node into BST Can we rewrite this
algorithm
recursively?
insert(el)
if root is null // tree is empty; Yes – see
root becomes a new node with el; prescribed
textbook
return;
p = root;
while p is not null // find a place for inserting new
node;
prev = p;
if el < element in node p How many paths
through the tree do
p = p.left; we take?
else p = p.right;
if el < element in node prev
new node with el is attached to the left of prev;
else new node with el is attached to the right of prev;
Inserting a node into BST
20 30

null 20

25 10 15

20 20 20
30 30 10 30

25 25
Deleting a node from BST
 How do we delete nodes?
 First, use the search algorithm to find it
 Deleting a leaf is easy:

5 5

3 7 3 7

1 4 6 9 1 6 9
Deleting a node from BST

 Deleting a node with a single child is easy, too:

5 5

3 7 1 7

1 6 9 6 9
Deleting a node from BST

 Deleting a node with two children is less obvious:

3 3

1 8 1

6 10 6 10

5 7 5 7
Delete by merging
 Property of BST:
3
 all nodes to the left of n will be < n
 all nodes to the right of n will be > n
1 8 n
 If we take the largest node on
the left of n, it will be:
6 10
 > than all other nodes on the left
 < than all the nodes to the right of n
 It will always be the rightmost node of
the left branch 5 7

 The rightmost node in the left branch

of n can become a parent to the right Rightmost
branch of n node to the
left of n
Delete by merging
1. Start from the root
2. Find the node to be deleted
3. Go left, then find the rightmost node in the left subtree
4. The right subtree of n becomes the right subtree of the
rightmost node
5. The left child of n takes n’s place

3 3

1 8 1 6

6 10 5 7

5 7 10
Delete by merging: Tree Height

Deletion by merging
can have an adverse
effect on the tree
height
Delete by Copying
 Deletion by merging may change 3
the height of the tree and make it
inefficient
 Is there a better way? 1 8 n
 If we take the rightmost node on
the left, it will be: 6 10
 > than all nodes in the left branch
 < than all the nodes in the right branch
 Thus, it is a perfect candidate to replace
5 7
the deleted node!
 Instead of moving around
subtrees, we could just take the
rightmost node of the left Rightmost
node to the
subtree, and replace n with it left of n
Delete by Copying
3 3

1 8 1 7

6 10 6 10

5 7 5

 But what if the rightmost node has children?

 It’s rightmost, so there is no right child
 If there is a left child, it simply becomes the right child of
the rightmost node’s parent.
Delete by Copying

20 20 15
10 30 10 27 10 27

15 25 35 15
1 25 35 25 35
5
2327
27 2326 2326

26

delete delete
30 20
Other functions: FindMin and
FindMax
 What is the easiest way to find the
3
smallest value in a BST?
 Start at the root, go as far left as you
can.
1 8
 Leftmost node MUST be the smallest!

 …Largest value in a BST? 6 10

 Same, but you need to go right instead
of left
 Rightmost node is the largest 5 7
findMax (Node n) {
if (n != null) {
while(n.right !=
null) How many paths
n = n.right; through the tree do
}
we take?
return n;
}
 1
Other functions: countLeft 3

 What if you need to traverse the 1 8 1

0
entire BST?
 Example: count how many left children
are in the tree.
1 6 10 0
 Both left and right branch can have their
own left children!
 Solution: modify depth-first
0 5 7 0
traversal
protected void preorder(BSTNode<T>
p)
{ protected int countLeft(BSTNode<T> p)
if (p != null) { {
visit(p); if (p == null) return 0;
preorder(p.left); else {
preorder(p.right); if(p.left != null)
} return 1 + countLeft(p.left)
} +
countLeft(p.right);
else return
countLeft(p.right);
}
}
Summary
 Depth-first traversal
3
 Preorder, inorder, postorder

 Insertion into BST 1 8

 Search for an empty leaf position

 Deletion from BST 6 10

 By merging
 By copying
5 7

 Other functions
 One path followed: implement iteratively
 Entire tree needs to be traversed:
implement recursively