Binary Search Trees

Ms. Humaira Anwer

Khwaja Fareed UEIT
 When we store ordered data in an array, we have a
very efficient search algorithm, the binary search.
 However, we have very inefficient insertion and

deletion algorithms that require shifting data in the

array.
 To provide for efficient insertions and deletions, we
developed the linked list.
 The problem with linked lists, however, is that their

search algorithms are sequential searches, which are

very inefficient.
 Can’t we get the best of both worlds (i.e., efficient

search, insertion, and deletion algorithms)?

 The binary search tree is our answer!
 The binary search tree is a binary tree with the

following properties:
◦ All items (keys) in the left subtree are less than the root’s key.
◦ All items (keys) in the right subtree are greater than the root’s
key.
◦ Each subtree is, itself, a binary search tree.
◦ Assume each node of a binary tree stores a data item
◦ Assume data items are of some type that be ordered and all
items are distinct. No two items have the same value.
◦ A binary search tree is a binary tree such that
◦ for every node X in the tree:
 the values of all the items in its left subtree are smaller than the
value of the item in X
 the values of all items in its right subtree are greater than the
value of the item in X.
Here you can see the
basic structure of a
binary search tree.
 A binary search tree is organized as the name
suggests
 A tree can be represented by a linked data structure

where each node is an object

 In addition to a key field, each node contains fields

left, and right, that correspond to its left child and

right child
Key
Key Left
Left Right
Right

Key
Key Left Right Key Left Right
 If a child or parent is missing, the appropriate field
contains the value NULL.

 The root is only node in the tree, whose parent field is

NULL.

 Top of the tree is known as ‘root’ and the exposed nodes

at bottom are known as ‘leafs’.
 A binary search tree

6 6

2 8 2 8

1 4 1 4

3 3 7

Not a binary search tree,

but a binary tree
- a & b are full and BST
-a, b, & d are complete
-c and e are skewed
Here we see examples of binary a) 22 > 17
b) 11 < 17
trees that are not binary search c) 11 > 6
trees … why? d) 22 > 17
 Note: we have written this definition in a way that
ensures that no two entries in a binary search tree
can have equal keys.

 Although it is possible to modify the definition to

allow entries with duplicate keys, it makes the
algorithms somewhat more complicated.

 If duplicates need to be accounted for, they can be

stored in another data structure (e.g., list).
• The search tree property does not say what happens
with the elements with the same key.
• In our examples, all the keys will be distinct but in
practice it is important to cover the case of multiple
elements with the same key (duplicate keys).
• The duplicate keys can all be kept in the left subtree, or
all in the right subtree.
• It doesn’t matter which we choose, but it matters that
the choice is the same for the whole implementation.
• Another issue: with duplicate keys, it is important to
have extra operations in the interface: getAll, and
removeAll
 Binary trees offer short paths from root
 A node has up to two children
 Data is organized by value
 Operations:

◦ Insertion
◦ Search
◦ Traversal
◦ Deletion
 Find Minimum
 Find the item that has the minimum value in the tree
 Find Maximum
 Find the item that has the maximum value in the tree
 Print
 Print the values of all items in the tree using a traversal strategy
that is appropriate for the application

 Successor
 Predecessor
 The first value inserted goes at the root
 Every node inserted becomes a leaf
 Descend left or right depending on value
Inserting Item 5 to the Tree
t
6 Tree root node

t
2 8 NULL NULL

t
1 NULL NULL 4 NULL

3 NULL NULL 5 NULL NULL

New Node
ALGORITHM
If node == NULL
return createNode(data)
if (data < node->data)
node->left = insert(node->left, data);
else if (data > node->data)
node->right = insert(node->right, data);
return node;
1. void insert(int key) {root = insertKey(root, key);}
2. // Insert key in the tree
3. Node insertKey(Node root, int key) {
4. // Return a new node if the tree is empty
5. if (root == null)
6. {
7. root = new Node(key);
8. return root;
9. }
10. // Traverse to the correct place and insert the node
11. if (key < root.key)
12. root.left = insertKey(root.left, key);
13. else if (key > root.key)
14. root.right = insertKey(root.right, key);
15. return root;
16. }
 If z has no children, we modify its parent to replace z
with NULL as child.

 If z has one child, we splice out z by making a new link

between its child and its parent.

 If node has two children, we splice out z’s successor y,

which has no left child and replace the contents of z
with the contents of y.
Three cases for remove(x):

x occurs at a leaf: simply remove the node containing x

25

15 40

5 20 45 25

15 40
18
removeElement(45)
-------------> 5 20

18
x occurs at a node with one child v: remove the node
containing x and make v a direct child of x’s parent (if any).

25

15 40

5 20 45

18
removeElement(20) 25
------------->
15 40

5 18 45
x occurs at a node with two children: first replace x with
smallest value in right subtree of x. This value occurs at a
node with no left child. So we can delete this node using
one of the two previous cases.
25

15 40

5 20 45
25

18 18 40

removeElement(15)
5 20 45
------------->

18 <--- Now remove this

 6 6

2 8 3 8

1 5 1 5

3 3

4 Deletion of node 2. 4
before after
There are three cases for deleting a node from a binary search tree.
CASE I
 In the first case, the node to be deleted is the leaf node. In such a case, simply delete the
node from the tree.

4 is to be deleted
There are three cases for deleting a node from a binary search tree.
CASE I
 In the first case, the node to be deleted is the leaf node. In such a case, simply delete the
node from the tree.

4 is deleted
Case II
1.Inthe second case, the node to be deleted lies has a single child node. In such a case follow the steps
below:
2.Replace that node with its child node.

3.Remove the child node from its original position.

6 is to be deleted
Case II
1.Inthe second case, the node to be deleted lies has a single child node. In such a case follow the steps
below:
2.Replace that node with its child node.

3.Remove the child node from its original position.

copy the value of its child to the node and delete the child
Case II
In the second case, the node to be deleted lies has a single child node. In such a case follow the steps
below:
1. Replace that node with its child node.
2. Remove the child node from its original position.

Final tree
Case III
In the third case, the node to be deleted has two children. In such a case follow the steps below:
1. Get the inorder successor of that node.
2. Replace the node with the inorder successor.
3. Remove the inorder successor from its original position.

3 is to be deleted
Case III
In the third case, the node to be deleted has two children. In such a case follow the steps below:
1. Get the inorder successor of that node.
2. Replace the node with the inorder successor.
3. Remove the inorder successor from its original position.

Copy the value of the inorder successor (4) to the node

Case III
In the third case, the node to be deleted has two children. In such a case follow the steps below:
1. Get the inorder successor of that node.
2. Replace the node with the inorder successor.
3. Remove the inorder successor from its original position.

Delete the inorder successor

1. void deleteKey(int key) {root = deleteRec(root, key);}
2. Node deleteRec(Node root, int key) {
3. // Return if the tree is empty
4. if (root == null)
5. return root;
6. // Find the node to be deleted
7. if (key < root.key)
8. root.left = deleteRec(root.left, key);
9. else if (key > root.key)
10. root.right = deleteRec(root.right, key);
11. else {
12. // If the node is with only one child or no child
13. if (root.left == null)
14. return root.right;
15. else if (root.right == null)
16. return root.left;
17. // If the node has two children
18. // Place the inorder successor in position of the node to be deleted
19. root.key = minValue(root.right);
20. // Delete the inorder successor
21. root.right = deleteRec(root.right, root.key);
22. }
23. return root;
24. }
 The BST property allows us to print out all keys in BST in
sorted order using a simple recursive algorithm.

public void traverseInOrder(Node node)

{
if (node != null)
{
traverseInOrder(node.left);
System.out.print(" " + node.key);
traverseInOrder(node.right);
}
}
4, 7, 16, 20, 37, 38, 43
BST-inorder-traverse (node)
1. If node has left child
BST-inorder-traverse (Left(node))
2. Apply operation to node (e.g. print)
3. If node has right child
BST-inorder-traverse (Right(node))

 Order for tree above: 1, 2, 3, 5, 6, 7

 Application: Display tree in ascending order
 // Traverse Preorder
 public void traversePreOrder(Node node) {
 if (node != null) {
 System.out.print(" " + node.key);
 traversePreOrder(node.left);
 traversePreOrder(node.right);
 }
 }

•Order for tree above: 3, 1, 2, 6, 5, 7

•Application: Copy BST
 // Traverse Postorder
 public void traversePostOrder(Node node) {
 if (node != null) {
 traversePostOrder(node.left);
 traversePostOrder(node.right);
 System.out.print(" " + node.key);
 }
 }

• Order for tree above: 2, 1, 5, 7, 6, 3

• Application: Deallocate BST
 Given a Binary Tree, convert it to a Binary Search
Tree. The conversion must be done in such a way that
keeps the original structure of Binary Tree.

 Submission in hadwritten hard form

 Submission Deadline: 2/12/2022 by 4: PM

 Want to search for key stored in BST
Functions:
 Tree search

 Minimum

 Maximum

 Successor

 Predecessor
 This function follows the BST property,
 if value of k is smaller than that of x, then it should be in left sub
tree of x,
 else it should be in right sub tree of x.

2 8

1 4

3
 Start at the root
 Is target = value at current node?

◦ We’re done

 Is target < value at current node?

◦ Yes: search left subtree
◦ No: search right subtree
Search Starts from the Root
 When given a pointer to the root of a tree and a key, Tree-Search
will return a pointer to the node with key k if one exists (x = root).

ALGORITHM
If root == NULL
return NULL;
If number == root->data
return root->data;
If number < root->data
return search(root->left)
If number > root->data
return search(root->right)
 The minimum element of BST is the left most node of
left sub tree.
 Therefore the minimum can always be found by
tracking the left child pointers until an empty sub tree
is reached.
 If there is no left sub tree then minimum key is at
root( i.e. key[ x])
Tree-Minimum(x)
{
while( left[ x] != NULL)
x = left [x]
return x
}
 The maximum element of BST is the right most node of
right sub tree.
 Therefore the maximum can always be found by tracking
the right child pointers until an empty sub tree is reached.

Tree-Maximum( x)
{
while( right[ x] != NULL)
x = right [x]
return x
}
 The successor of a node x, is node y, that has the smallest
key greater than that of x.
◦ If x has a right subtree, then successor(x) is the left most
element in that sub tree.

◦ If x has no right sub tree, then successor(x) is the lowest

ancestor of x (above x on the path to the root) that has x in its
left sub tree.
• The successor of node with key 15 is node with key 17.
• The successor of node with key 7 is node with key 9.
• The successor of node with key 13 is node with key 15.
 The predecessor is the node that has the largest key
smaller than that of x

◦ If x has a left sub tree, then the predecessor must be the right
most element of the left sub tree.

◦ If x has no left subtree, then predecessor (x) is the lowest

ancestor of x (above x on the path to the root) that has x in its
right subtree.
• The predecessor of node with key 6 is node with key 4.
• The predecessor of node with key 15 is node with key 13.
• The predecessor of node with key 17 is node with key 15.