Download Slide 1

CS212: DATA STRUCTURES
Computer Science
Department
Lecture 6: Binary Trees
Trees, Binary Trees, and
Binary Search Trees




Linked lists usually are more flexible than arrays, but it is difficult
to use them to organize a hierarchical representation of objects.
Stacks and queues reflect some hierarchy but are limited to only
one dimension.
For these reasons, create a new data type tree that consists of
nodes and arcs/edges and has the root at the top and the leaves
(terminal nodes) at the bottom.
Tree Representation
 Tree generally implemented in the computer using pointers
Tree Terminology / concepts
Path : a unique sequence of arcs or the resulting sequence of
nodes.
 Root : the node at the top of the tree. (one node / one path)
 Leaf : a node that has no children.
 Subtree : any node can be considered to be the root of a subtree,
which consists of its children, and its children's children, and so on.
 Level of the node :
 The length of the path from the root to the node.
 Level of a node is its distance from the root.

Tree Terminology cont’





Parent : Any node (except the root) has exactly one edge running
upward to another node or
 A node is a parent if it has successor nodes; that is, if it has
outdegree greater than zero.
Child : Any node can have one or more lines running downward to
other nodes.
 It has a predecessor node
Siblings :Two or more nodes with the same parent
Ancestor : Any node in the path from the root to the node
Descendent :
 Any node in the path below the parent node
 All nodes in the paths from a given node to a leaf node
Tree Terminology cont’





Length : the number of arcs in a path.
Height of non empty tree : the maximum level of a node in the
tree.
 Is the level of the leaf in the longest path from the root + 1
 The height of an empty tree is -1
 Depth == Height
Visiting : a node is visited when program control arrives at the
node, usually for the purpose of carrying out some operation on
the node.
Traversing : to visit all the nodes in some specified order.
Key : a value that is used to search for the item or perform other
operations on it.
A
Subtree B
B
C
9
Root of Subtree I
E
D
F
G
H
I
Binary Tree


It is a tree whose nodes have two children (possibly empty), and
each child is designed as either a left child or a right child.
 If it has 2i nodes at each level i+1, it is called complete binary
tree: all nonterminal nodes have both their children and all
leaves are at the same level.
The binary search tree :
 Also called ordered binary trees
 For each node n, all values stored in its left subtree are less
than value v stored in n, and all values stored in the right
subtree are greater than v.
Examples of binary trees
Implementing Binary Tree

Why tree / binary tree ?
 An ordered array is quick in search using binary search ,
but it is slow in insertion and deleting nodes
 Linked list is quick in insertion and deletion but slow in
searching
 So, you may use a tree because it combines the
advantages of the other two structures: an ordered array
and a linked list.

1.
2.

Binary tree can be implemented as :
A linked list.
An Array.
Declare a node as a structure with an information field and two
“pointers” fields.

However, it may has problems when deleting and inserting
nodes
Searching a Binary Search Tree

For every node, compare the key to be located with the value
stored in the node currently pointed at.
1.
If key is less than the value, go to the left subtree and try
again.
2.
If it is greater than that value, try the right subtree.
3.
If it is the same, the search stops.
4.
The search is aborted if there is no way to go – the key is not
in the tree.
Algorithm : BST Search
17
algorithm searchBST (ref root <pointer>, val argument
<key>)
1.
if (root is null)
1.
return null
2.
end if
3.
if (argument < root->key)
1.
return searchBST (root->left, argument)
4.
elseif (argument > root->key)
1.
return searchBST (root->right, argument)
5.
else
1.
return root
6.
end if
end searchBST



The complexity of searching is measured by the number of
comparisons performed.
 This number depends on the number of nodes encountered
on the unique path leading from the root to the node being
searched for.
So, the complexity is the length of the path leading to this node
plus 1.
Complexity depends on
1. The shape of the tree.
2. The position of the node in the tree.
Unbalanced Trees

Some of the trees are unbalanced, that is, they have most of
their nodes on one side of the root or the other. Individual
subtrees may also be unbalanced.
1. Finding a Node

Finding a node with a specific key is the simplest of the major
tree operations. Remember that the nodes in a binary search
tree correspond to objects containing information, one of them
can be considered as a key.
Efficiency of the Find Operation


How long it takes to find a node depends on how
many levels down it is situated.
For example, there can be up to 31 nodes, but no
more than 5 levels. Thus you can find any node
using a maximum of only 5 comparisons.
2. Inserting a Node
1.
2.
3.
Find the place to insert it. This is much the same
process as trying to find a node which turns out not to
exist.
Follow the path from the root to the appropriate
node, which will be the parent of the new node.
After this parent is found, the new node is connected
as its left or right child, depending on whether the
new node's key is less or greater than that of the
parent.
Algorithm : Recursively add node
to BST
algorithm addBST (ref root <pointer>, val new <pointer>)
1.
if (root is null)
1. root = new
2.
else
Locate null sub-tree for insertion
1. if (new->key < root->key)
1. addBst (root->left, new)
2. else
1. addBst (root->right, new)
3. end if
3.
end if
4.
return
end addBST
26
27
28
29
3. Deleting a Node


Deleting a node is the most complicated common operation
required for binary search trees. However, deletion is
important in many tree applications.
There are three cases to consider:1- The node to be deleted is a leaf node (has no children).
2- The node to be deleted has one child.
3- The node to be deleted has two children.

Case1 : The node to be deleted has no children
To delete a leaf node, change the appropriate child
field in the node's parent to point to null, instead of
to the node.

Case 2 : The node to be deleted has one child
The node has only two connections: to its parent and to
its only child. You want to "snip" the node out of this
sequence by connecting its parent directly to its
child.

Case 3 : The node to be deleted has two children
If the deleted node has two children, you can't just
replace it with one of these children, at least if the
child has its own children.
 To delete a node with two children, replace the
node with its in order successor.
35
24-May-17
Computer Science Department
Deleting a Node
Deleting a Node
38
39
4.

Finding Maximum and Minimum values
For the minimum, go to the left child of the root; then go to the
left child of that child, and so on, until you come to a node
that has no left child. This node is the minimum:
Algorithm : Find Smallest
41
algorithm findSmallestBST (val root <pointer>)
1.
if (root->left null)
return (root)
2.
end if
3.
return findSmallestBST (root->left)
end findSmallestBST

For the maximum value in the tree, follow the same
procedure, but go from right child to right child
until you find a node with no right child. This node
is the maximum.
Algorithm : Find Largest
43
algorithm findLargestBST(val root <pointer>)
1.
if (root->right null)
return (root)
2.
end if
3.
return findLargestBST(root->right)
end findLargestBST
Summary






Trees consist of nodes (circles) connected by edges (lines).
The root is the topmost node in a tree; it has no parent.
In a binary tree, a node has at most two children.
In a binary search tree, all the nodes that are left descendants
of node A have key values less than A; all the nodes that are A’s
right descendants have key values greater than (or equal to) A.
Nodes represent the data-objects being stored in the tree.
Edges are most commonly represented in a program by pointers
to a node's children (and sometimes to its parent).
Summary (cont’)



An unbalanced tree is one whose root has many more left
descendents than right descendants, or vice versa.
Searching for a node involves comparing the value to be found
with the key value of a node, and going to that node's left child if
the key search value is less, or to the node’s right child if the
search value is greater.
Insertion involves finding the place to insert the new node, and
then changing a child data member in its new parent to refer to it.
46
End Of Chapter
References:
•
Text book, chapter 6: Binary Trees
24-May-17
Computer Science Department