Binary Trees and Binary Search Trees—C++ Implementations

Learning Goals:

• Apply basic tree definitions to classification problems.

• Describe the properties of binary trees, binary search trees,
and more general trees; and implement iterative and
recursive algorithms for navigating them in C++.
• Insert and delete nodes in a binary tree.
• Compare and contrast ordered versus unordered trees in
terms of complexity and scope of application.
• Describe and use preorder, inorder and postorder tree
traversal algorithms.
• Provide examples of the types of problems for which tree
data structures are well-suited.

CPSC 221 Binary Trees Page 1

In a sorted array, we can search for an element using binary search—

an O(lg n) operation. In this section, we generalize this concept to
binary trees.
Definition: A binary tree is a data structure that is either empty or
consists of a node called a root and two binary trees called the left
subtree and right subtree, one or both of which may be empty.

Note that this definition is recursive – we define a binary tree as a

structure that consists of two other (sub)trees.

CPSC 221 Binary Trees Page 2

1
 Domain: A set of nodes containing: (a) some application data (e.g.,
one or more of: name, student #, GPA, …), and (b) two (possibly
NULL) pointers to other nodes.
Structure: There is a unique root node (that has no parent node)
having zero, one, or two child nodes; every other node has exactly
one parent node and either zero, one, or two children.
Operations:
insertLeft - insert new node as left child of given node
insertRight - insert new node as right child of given node
find - find node containing given item (i.e., a “search key”)
findParent - find parent of given node
deleteItem - remove node containing given item
print - print data in the tree
etc.

CPSC 221 Binary Trees Page 3

Some Terminology:
The path from node N1 to node Nk is a sequence of nodes
N1, N2, …, Nk where Ni is the parent of Ni+1. The length of the path
is the number of edges in the path. (Warning: Some texts use the
number of nodes rather than the number of edges).
The depth or level of a node N is the length of the path from the root
to N. The level of the root is 0.
The height of a node N is the length of the longest path from N to a
leaf node (a node with no child). The height of a leaf node is 0.
The height of a tree is the height of its root node
node. The height of the
empty tree is –1. The root appears at level 0.
The number of nodes in a tree of height h is at least h+1 and no more
than 2h+1-1.

CPSC 221 Binary Trees Page 4

2
 E

H C

B D J I

F G
A
Height of tree:
Depth of node containing B:
Height
i h off node
d containing
i i B:
# of nodes in this tree:
# of leaves (i.e., external nodes):
# of non-leaf (i.e., internal) nodes:
CPSC 221 Binary Trees Page 5

Full Binary Tree: Each node has exactly 0 or 2 children. Each

internal node has exactly ___ children; each leaf has ___ children.
Examples:

Complete Binary Tree: A full binary tree where all leaves have the
same depth. Examples:

Nearly
N l Complete
C l t Binary
Bi Tree:
T All leaves
l on the
th last
l t level
l l are
together on the far left side, and all other levels are completely filled.
Examples:

CPSC 221 Binary Trees Page 6

3
 At this stage in the course, we assume that binary trees are arbitrarily
ordered (i.e., there is no order to their keys).
The number of distinct binary trees with n nodes is given by the
Catalan number having the formula:
f(n) = (2n)! / ((n+1)!n!)
How many distinct binary trees are there when n=3?

Draw them.

CPSC 221 Binary Trees Page 7

Implementation of a Binary Tree in C++

We will assume that a typedef statement has defined Item_type to
be the type of data to be stored in the tree. Each node contains an
item, a pointer to the left subtree and a pointer to the right subtree:
typedef string Item_type;
Item type;
struct BNode
{
Item_type item; // may have many data fields
BNode* left;
BNode* right;
};

We will now look at the implementation of some of the operations

listed earlier.
To begin, we will write a makeNode function to create a new BNode
as needed. Note the default assignments in the argument list:

CPSC 221 Binary Trees Page 8

4
 Bnode * makeNode(const Item_type& item,
Bnode * leftChild = NULL, Bnode * rightChild = NULL)
// PRE: item is valid, leftChild points to a node or is
// NULL, rightChild points to a node or is NULL
// POST: a new node is created and its address is
// returned
{
Bnode * temp;
temp = new Bnode;
temp->item = item;
temp->left = leftChild;
i
temp->right = rightChild;
return temp;
}

CPSC 221 Binary Trees Page 9

Bnode * makeNode( const Item_type& item,

Bnode * leftChild = NULL, Bnode * rightChild = NULL)
Notes:
A sample calling statement is:

Recall, when leaving a function in C++, we:

(a) Pass back the appropriate return value to the caller. In the calling
statement, the return value actually replaces the whole function call,
but only the function call (since there may be more things to do).
(b) Destroy all temporary variables in the function, but retain the
dynamically allocated ones (and any with keyword “static”).
(c) Return to the caller, and continue execution with the rest of the
calling statement, if anything in the calling statement remains.
CPSC 221 Binary Trees Page 10

5
 Consider the insertLeft function. This function is used to insert an
item in a node to the left of a current node (or to create a new binary
tree). We assume that current does not already have a left child; so
we are inserting into an “empty” spot in the tree:
void insertLeft( BNode*& current,
const Item_type& item )
// PRE: current points to a node in a binary tree or
// is NULL
// POST: if current is not null, the left child of
// current is a new node containing item; else,
// current points to a root node containing item
{
if (current) // same as: “if
if (current !=
! NULL)
NULL)”
current->left = makeNode(item);
else
current = makeNode(item);
}
CPSC 221 Binary Trees Page 11

Now let’s implement/complete the find function. This function will

be used to assist in the process of deleting an item from the tree. In
order to delete an item, we need to find the node that contains it.
BNode* find( BNode* root, const Item_type& item )
// PRE: root points to the root of a binary (sub)tree
// POST: if item is in the tree
tree, the address of the
// node containing item is returned; otherwise,
// NULL is returned
{
Bnode * temp;
if (root == NULL || root->item == item)
return root;
temp =

CPSC 221 Binary Trees Page 12

6
 We will now consider the deleteNode function. The task of
removing a node from a binary tree is quite complicated; therefore,
we will break the task into parts (a full version is on WebCT).
bool deleteNode( BNode*& root, const Item_type& item )
// PRE: root points to the root of a binary tree or is
// NULL
// POST: if item is in tree, first instance of node
// containing item has been deleted and true is
// returned; else, false is returned (only)
{
Bnode *temp, *parent;
temp
p = find(root, item);
if (!temp) // same as: if (temp == NULL)
return false;
// temp now points to the node containing item
parent = findParent(root, temp);
CPSC 221 Binary Trees Page 13

Now that we have a reference to the pointer that points to the node to
be deleted, we proceed according to one of 4 cases:
Case 1: node to be deleted is a leaf
if (isLeaf(temp))
{
if (parent) // “if (parent != NULL)”
if (parent->left == temp)
parent->left = NULL;
else
parent->right = NULL;
else
root = NULL;;

delete temp; // avoid memory leak

// see page 120 in Koffman text
return true;
}

CPSC 221 Binary Trees Page 14

7
 Case 2: node to be deleted has both a left and right child
This is the tricky case. There is no obvious way to remove a node
having two children and re-connect the tree. Instead, we will choose
not to delete the node but rather copy data from a leaf node (which is
easyy to remove)) into the current node. We will arbitrarilyy choose to
copy data from the leftmost leaf of the node to be deleted (if the
nodes’ keys are in arbitrary order).

See the example in the WebCT/Vista course notes, and in your

lab exercise.

CPSC 221 Binary Trees Page 15

Case 3: node to be deleted has only a left child

if ( hasLeftChild(temp) )
{
if (parent)
if (parent->left == temp)
parent->left = temp->left;
else
parent->right = temp->left;
else
root = temp->left;
p;
delete temp;
return true;
}

Case 4: node to be deleted has only a right child (see WebCT Vista)
(same idea)
CPSC 221 Binary Trees Page 16

8
 Tree Traversals
There are three common types of binary tree traversals:
Preorder (prefix): “process” the current node, then recursively visit
its left subtree, then recursively visit its right subtree
5

8 3

2 4 0 7

9 1
6

Data printed using preorder traversal:

CPSC 221 Binary Trees Page 17

Inorder (infix): visit the left subtree, then process the current node,
then visit the right subtree
5

8 3

2 4 0 7

9 1
6
Data printed using inorder traversal:

CPSC 221 Binary Trees Page 18

9
 Postorder (postfix): visit the left subtree, then visit the right subtree,
then process the current node
5

8 3

2 4 0 7

9 1
6
Data printed using postorder traversal:

CPSC 221 Binary Trees Page 19

Let’s consider how we would implement a function that traverses a

binary tree using inorder traversal (recursively) and applies a function
to each node visited:
void inorder( BNode* root, void (*process)(BNode*) )
// PRE: root points to a binary tree or is NULL
// POST: function process() has been applied to each node
// in the tree, using inorder traversal
{

The implementation of the functions to perform preorder or postorder

traversal is left as an exercise.
CPSC 221 Binary Trees Page 20

10
 An Application: Binary Expression Trees
Arithmetic expressions can be represented using binary trees. We
will build a binary tree representing the expression:
(3+2)*5–1
We start by identifying the operator with the highest precedence and
build a binary tree having the operator at the root, the left operand as
the left subtree and the right operand as the right subtree. We
continue in this fashion until all operators have been represented:
(3 + 2 )

(3 + 2) * 5

CPSC 221 Binary Trees Page 21

(3 + 2) * 5 – 1

Now let’s print this expression tree using postorder traversal:

What we now have is the arithmetic expression written using

Reverse Polish Notation (RPN). It turns out to be much easier to
write an algorithm to evaluate an expression written in RPN than
using the common arithmetic notation found at the top of this page.

CPSC 221 Binary Trees Page 22

11
 Binary Search Trees (Review, and C++ Implementation):
A binary search tree (BST) is a binary tree such that for every node
v in the tree: (a) all of the keys (elements) in v’s left subtree are ≤
v’s key, and (b) all of the keys in v’s right subtree are ≥ v’s key.

6 6
3 7 5 7

2 5 9 2 3 9

a binary search tree not a binary search tree

The order of the keys in the nodes is important!

CPSC 221 Binary Trees Page 23

Common Operations on BST’s

Searching for a Key (called a Search Key) in a BST
Algorithm:
If tree is empty then search key is not present, and we’re done
If search key = root
root’ss key, we
we’ve
ve found it, and we
we’re
re done
If search key < root’s key then
Search left subtree
else
Search right subtree 6
3 7

2 5 9

CPSC 221 Binary Trees Page 24

12
 In the following implementations of the Search function, we assume
that the nodes of the binary search tree are represented as follows:
template<typename Key, typename Value>
struct BNode
{
Key key;
Value value;
Bnode * left;
Bnode * right;
};

Example of calling sequence from main() or another function:

Bnode int, string>*
Bnode<int, string myFirstTree;
Bnode<char, float>* mySecondTree;
string myString;
float num;
... // initialization and other code
search(myFirstTree, 5, myString); // see next page
search(mySecondTree, ‘w’, num);

CPSC 221 Binary Trees Page 25

Recursive Implementation of Search Function: If key is found,

return true and the “value” associated with the key; else return false.
template<typename Key, typename Value>
bool search(BNode<Key, Value>* root,
const Key& key, Value& value)
{
if (root == NULL)
return false;
if (root->key == key)
{
value = root->value;
return true;
}
if (key < root->key) // search left subtree
return search(root->left, key, value);
else // search right subtree
return search(root->right, key, value);
}

CPSC 221 Binary Trees Page 26

13
 Alternatively, if we want to return a pointer to the node containing
the found search key (or NULL if no such node exists), we can use
the following code (and this time, we’ll use an iterative version):
template<typename Key, typename Value>
BNode<Key, Value>* search( BNode<Key, Value>* root,
const Key& key
k )
{
while (root && root->key != key)
if (key > root->key)
root = root->right; // right subtree
else
root = root->left; // left subtree
return root;
}

CPSC 221 Binary Trees Page 27

Inserting an Item into a BST:

Algorithm:
If tree is empty, then insert item as root
If key = root’s key, then replace root’s value with new value
If key < root’s key, then insert into root’s left subtree
else
l insert
i i
into root’s
’ right
i h subtree
b
Here is a possible prototype for this function:
template<typename Key, typename Value>
void insert( BNode< Key, Value >*& root,
const Key& key, const Value& value );

CPSC 221 Binary Trees Page 28

14
 Drawing exercise: Insert the following keys (we won’t worry about
the corresponding values) into an empty binary search tree in the order
given. Note that in both cases, the data is the same but the order in
which we do the insertion is different.
Case 1: 7, 4, 3, 6, 9, 8

Case 2: 3, 4, 6, 7, 8, 9

CPSC 221 Binary Trees Page 29

Note that in Case 1, we end up with a “bushy tree”; in fact, it is a

nearly complete binary tree. If we search for an item in a complete
(or nearly complete) binary tree, it takes O(______) worst-case time.
In Case 2, our tree is rather “unbalanced” or “one-sided”. Searching
for an item in this tree would take O(________)
O( ) worst
worst-case
case time.
Our insertion algorithm makes no attempt to balance the tree—it
maintains only an ordering property, not a shape property. In this
sense, a binary search tree is very different from a binary heap.
(We’ll study heaps, later.)
It can be shown that, on average, with random insertion, the depth of
a binary search tree is O(_______).

CPSC 221 Binary Trees Page 30

15
 Removing an Item from a BST
Algorithm:
Search for the item to find the node containing the item.
If the item was not found, we’re done.
If the node is a leaf, delete the node.
If node’s
d ’ lleft
f subtree
b iis empty, replace
l node
d with
i h right
i h child
hild
else if node’s right subtree is empty, replace node with left child
else replace node with its logical predecessor (rightmost node of
its left sub-tree)

Delete 5 from tree: 6

3 7

2 5 9

CPSC 221 Binary Trees Page 31

Delete 7 from tree:

6
3 7

2 5 9

Delete 6 from tree:

6
3 7

2 5 9

Note that by replacing the node with its logical predecessor (or logical
successor), we maintain the ordering property of the binary search tree.
CPSC 221 Binary Trees Page 32

16
 Finding the Smallest Key in a BST, Recursively
Assuming the tree is reasonably balanced, we can access the smallest
(or largest) item in O(_____) time because the smallest and largest
items in a BST are stored in the extreme left and extreme right nodes
of the tree.

template<typename Key, typename Value>

void findSmallest( BNode< Key, Value >* root,
Key& key, Value& value )
//Pre: BST root is not NULL
//Post: return key AND value of smallest key
{

}
CPSC 221 Binary Trees Page 33

A BST implementation of a map is also beneficial if we want the data

sorted by key value. Suppose we want to print the data to the screen,
sorted by key. This would be a(n) ______________ traversal.
template<class Key, class Value>
void printData( BNode< Key, Value >* root )
{

This is a Θ(____) operation (worst case, average case, and best case).

CPSC 221 Binary Trees Page 34

17