Binary Search Tree Operations

CS146

Chris Pollett

Apr 9, 2014

Outline

BST Search
BST Min and Max
BST Successor and Predecessor
BST Insertion and Deletion

Introduction

On Monday, we started talking about binary search trees.
We defined such tree as binary tree with the binary search property. This roughly says for each node in a BST, that the key of the node is greater than or equal to the keys of nodes in its left subtree and less than or equal to keys of nodes in its right subtree.
We then gave an algorithm for doing inorder walks on BST's.
We start today by looking at algorithm for other dynamic set operations using BST's...

Querying a BST

To search for a value `k` in a BST rooted at `x`, we can start at `x`and use the following pseudo-code:

TREE-SEARCH(x,k)
1 if x == NIL or k == x.key
2    return x
3 if k < x.key
4    return TREE-SEARCH(x.left, k)
5 else return TREE-SEARCH(x.right, k)

This function returns a pointer to a node with key `k` if one exists; otherwise, it returns NIL.

Example Search

Suppose we search for 13 in the above tree.
We start by calling TREE-SEARCH(root, 13). Because of line 3, this would in turn call, TREE-SEARCH(node(6), 13), TREE-SEARCH(node(7), 13), TREE-SEARCH(node(13), 13), at which point node(13) would be returned.
By node(x), I mean the node in the above diagram with key `x`.

ITERATIVE-TREE-SEARCH(x,k)

We can get rid of the recursion in TREE-SEARCH using a while loop as follows:

ITERATIVE-TREE-SEARCH(x,k)
1 while x != NIL and k != x.key
2    if k < x.key
3        x = x.left
4    else x = x.right
5 return x

Minimum and Maximum

To find the smallest element in a BST, we keep following the left child pointers from the root until we reach NIL.
In the tree of the previous slide the last node we go through doing the above would be 2, the minimum for that tree.
Implementing the above idea, yields the following pseudo-code for minimum
```
TREE-MINIMUM(x)
1 while x.left != NIL
2    x = x.left
3 return x
```
Computing maximum is the symmetric idea following right child pointers:
```
TREE-MAXIMUM(x)
1 while x.right != NIL
2    x = x.right
3 return x
```

Successor

Given a node `x` in a BST, sometimes we need to find the node with the next larger or equal key value in the tree
Basically, this amounts to finding the minimal node in the right sub-tree of `x`, if it exists.
If the right sub-tree doesn't exists, we go up the tree looking for the first ancestor node that we are the left child of.
Two slides back this second situation occurs when we look for the successor of 13.

The pseudo-code for tree successor looks like:

TREE-SUCCESSOR(x)
1 if x.right != NIL
2    return TREE-MINIMUM(x.right)
3 y = x.p //remember p is parent
4 while y != NIL and x == y.right
5    x = y
6    y = y.p
7 return y

Predecessor and Run-times

The idea to compute predecessor is symmetric to successor: If x has a left sub-child we look for its max; otherwise, we look for the first ancestor of the current node that we are the right child of.
If we look at the run-times of the algorithms we have considered so far for search, min, max, successor, and predecessor they all involve moving always up or down a tree at each step until a NIL pointer has been seen or some other stop condition.
Hence, the run-times are all `O(h)` where `h` is the height of the tree. Let's state this as a theorem...

Theorem. The dynamic set operations SEARCH, MINIMUM, MAXIMUM, SUCCESSOR, and PREDECESSOR can be implemented so that each one runs in `O(h)` time on a BST of height `h`.

Insertion

To insert a new value `v` into a BST `T`, we initialize a node `z` such that `z.key = v`, `z.\l\eft = NIL` and `z.r\i\g\h\t = NIL`. Then we call the following procedure:

TREE-INSERT(T, z)
 1 y = NIL
 2 x = T.root
 3 while x != NIL
 4    y = x
 5    if z.key < x.key
 6       x = x.left
 7    else x = x.right
 8 z.p = y
 9 if y == NIL
10     T.root = z //tree T was empty
11 elseif z.key < y.key
12    y.left = z
13 else y.right = z

Example Insert

Suppose we want to insert 13 into the tree above before the dashed 13 edge. So `z` would be set to have `z.key`=13
Lines 3-7 involve searching down the tree along the lightly colored nodes to find the location to place it.
As we search down the tree we keep track of the previous node we were at using a trailing pointer y.
Once we get to a NIL pointer, we know at least one of `y` children is NIL at a place where we could and z and still have the BST property.
We then use lines 9-13 to determine where to hang the node `z`.
Like the other operations this procedure is `O(h)`.

Deletion

There are three cases to consider when deleting a node `z` from a BST `T`:
- If `z` has no children, then we simply remove it by modifying its parent to replace with NIL as its child.
- If `z` has just one child, then we elevate that child to take `z`'s position in the tree by modifying `z`'s parent to replace `z` by `z`'s child
- If `z` has two children, then we find `z`'s successor `y` -- which must be in `z`'s right subtree -- and have `y` take `z`'s position in the tree. The rest of `z`'s original right subtree becomes `y`'s new right subtree, and `z`'s left subtree becomes `y`'s new left subtree. This case is a little tricky.

Example Illustrating the Different Cases

The above diagram illustrates the different cases of BST Delete. The trivial case of a one node tree is omitted.
(a) and (b) represent what we do when `z` has at least one NIL pointer.
In case (c), `z` has both children, `y` is both its right child and its successor. In this case, we case just move `y` up to replace `z` and hang the left child of `z`, `l` as `y`'s left child.
In case (d), the sucessor `z` is not the right child of `z`. Any successor `z` must have its left child NIL. So in this case, we first make `y`'s right child's parent, `y`'s parent. Then we make `y` the parent of `z`'s right child. This operation correspond to the middle trees listed in (d). Then we make `y`'s new parent be `z`'s parent and we hang `l`, `z`'s left sub-child off as the left sub-child of `y`.

Transplanting Trees

In order to move subtrees around within a BST, we define a subroutine TRANSPLANT, which replaces one subtree as a child of its parent with another subtree.
When transplant replaces the subtree rooted at node `u` with the subtree rooted at node `v`, node `u`'s parent becomes node `v`'s parent, and `u`'s parent ends up having `v` as its appropriate child.

Here is the pseudo-code:

TRANSPLANT(T, u, v)
1 if u.p == NIL
2     T.root = v
3 elseif u == u.p.left
4    u.p.left = v
5 else u.p.right = v
6 if v != NIL
7    v.p = u.p

Delete Pseudo-code

Given TRANSPLANT, we are now in a position to give the pseudo-code for TREE-DELETE:

TREE-DELETE(T, z)
 1 if z.left == NIL
 2    TRANSPLANT(T, z, z.right)
 3 elseif z.right == NIL
 4    TRANSPLANT(T, z, z.left) 
 5 else y = TREE-MINIMUM(z.right)
 6    if y.p != z
 7        TRANSPLANT(T, y, y.right)
 8        y.right = z.right
 9        y.right.p = y
10    TRANSPLANT(T, z, y)
11    y.left = z.left
12    y.left.p = y

Lines 1-4 handles the case where at least one of `z`'s children is NIL. Line 1-2 handle situation (a) from a couple slides back lines 3-4 handle situation (b).
Line 6, 10-12 handle case (c) from a couple slides back and also going from the middle trees of case (d) the the right tree. Lines 6-9 handle doing the transition from the left tree in case (d) to the middle pair of trees.
Each line of TREE-DELETE, including the calls to transplant takes constant time except the call to TREE-MINIMUM. Thus, TREE-DELETE run in time `O(h)` where `h` is the height of the tree.