Binary Search Trees (BSTs)

1
Binary Search Trees (BSTs)

• 18 February 2003

2
Binary Search Tree (BST)

• An important special kind of binary tree is the
  BST
• Each node stores some information including a
  unique key value, and associated data.
• A binary tree is a BST iff, for every node n in
  the tree
• All keys in ns left subtree are less than the
  key n
• All keys in ns right subtree are greater than
  the key n.
• Note if duplicate keys are allowed, then nodes
  with values that are equal to the key in node n
  can be either in ns left subtree or in its right
  subtree (but not both).

3
BSTs
4
Not BSTs
5
BSTs are Not Unique
2
1
3
4
6
Importance

• The reason binary-search trees are important is
  that the following operations can be implemented
  efficiently using a BST
• insert a key value
• determine whether a key value is in the tree
• remove a key value from the tree
• print all of the key values in sorted order

7
Lookup

• In general, to determine whether a given value is
  in the BST, we will start at the root of the tree
  and determine whether the value we are looking
  for
• is in the root
• might be in the roots left subtree
• might be in the roots right subtree
• There are actually two special cases
• The tree is empty return null.
• The value is in the root node return the value.

8
Lookup

• If neither special case holds, a recursive lookup
  is done on the appropriate subtree.
• Since all values less than the roots value are
  in the left subtree, and all values greater than
  the roots value are in the right subtree, there
  is no point in looking in both subtrees

9
Pseudo Code

• The pseudo code for the lookup method uses a
  recursive method
• lookup(BST, searchkey)
• if (BST null) return null
• if (BST.key searchkey) return BST.key
• if (BST.key gt searchkey) return lookup(BST.left,
  searchkey)
• else return lookup(BST.right, searchkey)

left key right
10
Look for 12
11
Searching for 12
12 lt 13 so go to the left subtree
12 gt 9 so go to the right subtree
Found!
12
Search for 15
15 gt 13 so go to the right subtree
15 lt 16 so go to the left subtree. It does not
exist so the search fails and it returns null
13
16
9
19
5
12
13
Animation

• http//www1.mmu.edu.my/mukund/dsal/BST.html

14
Analysis

• How much time does it take to search for a value
  in a BST?
• Note that lookup always follows a path from the
  root down towards a leaf. In the worst case, it
  goes all the way to a leaf.
• Therefore, the worst-case time is proportional to
  the length of the longest path from the root to a
  leaf (the height of the tree).

15
Worst Case

• What is the relationship between the number of
  nodes in a BST and the height of the tree?
• This depends on the shape of the tree.
• In the worst case, all nodes have just one child,
  and the tree is essentially a linked list.

16
Worst Case

• This tree has 5 nodes, and has height 5.
• Searching for values in the range 16-19, and
  21-29 will require following the path from the
  root down to the leaf (the node containing the
  value 20)
• Requires time proportional to the number of nodes
  in the tree

17
Best Case

• In best case, all nodes have 2 children
• All leaves are at the same depth
• This tree has 7 nodes, and height 3

18
Best Case Tree Height

• In general, a full tree will have height
  approximately log2(N), where N is the number of
  nodes in the tree.
• The value log2(N) is (roughly) the number of
  times you can divide N by two, before you get to
  zero.
• For example
• 7/2 3
• divide by 2 once 3/2 1
• divide by 2 a second time 1/2 0
• divide by 2 a third time, the result is zero so
  quit
• So log2(7) is approximately equal to 3.

19
Summary

• The worst-case time required to do a lookup in a
  BST is O(height of tree).
• The worst case (a linear tree) is O(N), where N
  is the number of nodes in the tree.
• In the best case (a full tree) we get O(log N).

20
Inserting 15
(1) 15 gt 13 so go to right subtree
(2) 15 lt 16 and no left subtree
(3) So insert 15 as left child
21
Complexity

• The complexity for insert is the same as for
  lookup
• In the worst case, a path is followed all the way
  to a leaf.

22
Delete

• If the search for the node containing the value
  to be deleted succeeds, there are several cases
  to deal with
• The node to delete is a leaf (has no children).
• The node to delete has one child.
• The node to delete has two children

23
Deletion

• If KeyToDelete in not in the tree, the tree is
  simply unchanged.
• We have to be careful that we do not orphan any
  nodes when we remove one.
• When the node to delete is a leaf, we want to
  remove it from the BST by setting the appropriate
  child pointer of its parent to null (or by
  setting root to null if the node to be deleted is
  the root, and it has no children).

24
Delete a leaf (15)
25
Delete a node with one child (16)
26
Messy Case

• The hard case is when the node to delete has two
  children.
• To delete n, we can't replace node n with one of
  its children, because what would we do with the
  other child?
• We replace node n with another node, x, lower
  down in the tree, then (recursively) delete node
  x.

27
Deletion

• What node can we use to replace node n?
• The tree must remain a BST (all of the values in
  ns left subtree are less than n, and all of the
  values in ns right subtree are greater than n)
• There are two possibilities that work the node
  in the left subtree with the largest value, or
  the node in the right subtree with the smallest
  value.
• To find that node, we just follow a path in the
  right subtree, always going to the left child,
  since smaller values are in left subtrees. Once
  the node is found, we copy its fields into node
  n, then we recursively delete the copied node.

28
Deletion (8)
29
Delete (8) Replace with (7)
30
Delete (8) Replace with (9)
31
Keeping BSTs Efficient

• In best of all worlds, BST is fully balanced at
  all times.
• In practical world, need BSTs to be almost
  balanced.
• A lot of CS research and energy has gone into the
  problem of how to keep binary trees balanced.

32
Height Balanced AVL Trees

• An AVL tree is a binary tree in which the heights
  of the left and right subtrees of the root differ
  by at most 1 and in which the left and right
  subtrees are AVL.

33
Splay Trees

• Self-adjusting data structure
• Splay trees are BSTs that move to the root the
  most recently accessed node.
• Nodes that are frequently accessed tend to
  cluster at the top of the tree driving those
  rarely accessed toward the leaves.
• Splay trees can become highly unbalanced, but
  over the long term do perform well.