CS2133 Lec08

Lecture No.
08
Trace of insert
14
4 15
3 9 18
7 p 16 20
5 node 17
17, 9, 14, 5 p->setRight( node );

Cost of Search
 Given that a binary tree is level d deep. How long does it take
to find out whether a number is already present?
 Consider the insert(17) in the example tree.
 Each time around the while loop, we did one comparison.
 After the comparison, we moved a level down.

Cost of Search
 With the binary tree in place, we can write a routine find(x)
that returns true if the number x is present in the tree, false
otherwise.
 How many comparison are needed to find out if x is present in

the tree?
 We do one comparison at each level of the tree until either x

is found or q becomes NULL.
Cost of Search
 If the binary tree is built out of n numbers, how many

comparisons are needed to find out if a number x is in the
tree?
 Recall that the depth of the complete binary tree built using ‘n’
nodes will be log2(n+1) – 1.
 For example, for n=1000,000, log2(1000001) is less than 20;

the tree would be 20 levels deep.
Cost of Search
 If the tree is complete binary or nearly complete, searching
through 1000,000 numbers will require a maximum of 20
comparisons.
 Or in general, approximately log2(n).
 Compare this with a linked list of 1000,000 numbers. The

comparisons required could be a maximum of n.
Binary Search Tree
 A binary tree with the property that items in the left subtree are
smaller than the root and items are larger or equal in the right
subtree is called a Binary Search Tree (BST).
 The tree we built for searching for duplicate numbers was a

binary search tree.
 BST and its variations play an important role in searching

algorithms.
Traversing a Binary Tree
 Suppose we have a binary tree, ordered (BST) or unordered.
 We want to print all the values stored in the nodes of the tree.
 In what order should we print them?

 Ways to print a 3 node tree:
14
4 15
(4, 14, 15), (4,15,14)

(14,4,15), (14,15,4)
(15,4,14), (15,14,4)
 In case of the general binary tree:
N node
L left right R
subtree subtree
(L,N,R), (L,R,N)
(N,L,R), (N,R,L)
(R,L,N), (R,N,L)
 Three common ways
N node
left right
L subtree subtree R
Preorder: (N,L,R)
Inorder: (L,N,R)
Postorder: (L,R,N)
void preorder(TreeNode<int>* treeNode)

{
if( treeNode != NULL )
{
cout << *(treeNode->getInfo())<<" ";
preorder(treeNode->getLeft());
preorder(treeNode->getRight());
}
}
void inorder(TreeNode<int>* treeNode)

{
{
inorder(treeNode->getLeft());
inorder(treeNode->getRight());
}
}
void postorder(TreeNode<int>* treeNode)

{
{
postorder(treeNode->getLeft());
postorder(treeNode->getRight());
}
}
cout << “preorder: "; preorder( root);
cout << "inorder: "; inorder( root );
cout << "postorder: "; postorder( root );

14
4 15
3 9 18
7 16 20
5 17
Preorder: 14 4 3 9 7 5 15 18 16 17 20
14
4 15
3 9 18
7 16 20
5 17
Inorder: 3 4 5 7 9 14 15 16 17 18 20
14
4 15
3 9 18
7 16 20
5 17
Postorder: 3 5 7 9 4 17 16 20 18 15 14
Recursive Call
 Recall that a stack is used during function calls.
 The caller function places the arguments on the stack and

passes control to the called function.
 Local variables are allocated storage on the call stack.
 Calling a function itself makes no difference as far as the call

stack is concerned.
Stack Layout during a call
 Here is stack layout when function F calls function F (recursively):
Parameters(F) Parameters(F) Parameters(F)

Local variables(F) Local variables(F) Local variables(F)
Return address(F) Return address(F) Return address(F)

sp
Parameters(F) Parameters(F)
sp
Local variables(F)
Return address(F)
sp
At point of call During execution of F After call
Recursion: preorder
14
preorder(14)
14
..preorder(4)
4 15 4
....preorder(3)
3
......preorder(null)
3 9 18 ......preorder(null)
....preorder(9)
7 20 9
16
......preorder(7)
7
........preorder(5)
5 17 5
..........preorder(null)
........preorder(null)
......preorder(null)
Recursion: preorder
14 ..preorder(15)
15
....preorder(null)
4 15 ....preorder(18)
18
......preorder(16)
3 9 18 16
7 ........preorder(17)
16 20
17
5 17 ..........preorder(null)
......preorder(20)
20
Recursion: inorder
14 inorder(14)
..inorder(4)
....inorder(3)
4 15 ......inorder(null)
3
......inorder(null)
4
3 9 18 ....inorder(9)
......inorder(7)
........inorder(5)
7 16 20 ..........inorder(null)
5
..........inorder(null)
5 17 7
........inorder(null)
9
......inorder(null)
14
Recursion: inorder
14 ..inorder(15)
....inorder(null)
15
4 15 ....inorder(18)
......inorder(16)
3 9 18 16
........inorder(17)
7 ..........inorder(null)
16 20
17
..........inorder(null)
5 17 18
......inorder(20)
20
Non Recursive Traversal
 We can implement non-recursive versions of the preorder,

inorder and postorder traversal by using an explicit stack.
 The stack will be used to store the tree nodes in the appropriate
order.
 Here, for example, is the routine for inorder traversal that uses
a stack.
void inorder(TreeNode<int>* root)

{
 Stack<TreeNode<int>* > stack;
TreeNode<int>* p;
p = root;
do
{
while( p != NULL )
{
stack.push( p );
p = p->getLeft();
}
// at this point, left tree is
empty

{
Stack<TreeNode<int>* > stack;
TreeNode<int>* p;
 p = root;
do
{
while( p != NULL )
{
stack.push( p );
p = p->getLeft();
}
empty

{
Stack<TreeNode<int>* > stack;
TreeNode<int>* p;
p = root;
do
{
 while( p != NULL )
{
stack.push( p );
p = p->getLeft();
}
empty
 if( !stack.empty() )
{
p = stack.pop();
cout << *(p->getInfo()) << " ";
// go back & traverse right subtree
p = p->getRight();
}
} while ( !stack.empty() || p != NULL );
}
if( !stack.empty() )
{
 p = stack.pop();
cout << *(p->getInfo()) << " ";
p = p->getRight();
}
}
{
p = stack.pop();
cout << *(p->getInfo()) << " ";

p = p->getRight();
}
}
{
p = stack.pop();
cout << *(p->getInfo()) << " ";
p = p->getRight();
 }
}
Nonrecursive Inorder
push(14)
14 ..push(4)
....push(3)
3
4
4 15 ..push(9)
....push(7)
......push(5)
5
3 9 18 7
9
14
7 16 20 push(15)
15
push(18)
..push(16)
5 17 16
..push(17)
17
18
push(20)
20
Traversal Trace
recursive inorder
nonrecursive inorder
inorder(14)
 ..inorder(4)
push(14)
....inorder(3)
..push(4)
3
....push(3)
4
3
..inorder(9)
4
....inorder(7)
..push(9)
....push(7)
......inorder(5)
......push(5)
5
5
7
7
9
9
14
14
inorder(15)
push(15)
15 15
inorder(18) push(18)
..inorder(16) ..push(16)
16 16
17 17
18 18
20 20
Traversal Trace
recursive inorder
inorder(14)
..inorder(4)
push(14)
....inorder(3)
..push(4)
3
....push(3)
 4
3
..inorder(9)
4
....inorder(7)
..push(9)
....push(7)
......inorder(5)
......push(5)
5
5
7
7
9
9
14
14
inorder(15)
push(15)
15 15
16 16
17 17
18 18
20 20
Traversal Trace
recursive inorder
inorder(14)
..inorder(4)
push(14)
....inorder(3)
..push(4)
3
....push(3)
4
3
..inorder(9)
4
 ....inorder(7)
..push(9)
....push(7)
......inorder(5)
......push(5)
5
5
7
7
9
9
14
14
inorder(15)
push(15)
15 15
16 16
17 17
18 18
20 20
Traversal Trace
recursive inorder
inorder(14)
..inorder(4)
push(14)
....inorder(3)
..push(4)
3
....push(3)
4
3
..inorder(9)
4
....inorder(7)
..push(9)
....push(7)
......inorder(5)
......push(5)
5
5
 7
7
9
9
14
14
inorder(15)
push(15)
15 15
16 16
17 17
18 18
20 20
Level-order Traversal
 There is yet another way of traversing a binary tree that is not related to
recursive traversal procedures discussed previously.
 In level-order traversal, we visit the nodes at each level before proceeding
to the next level.
 At each level, we visit the nodes in a left-to-right order.
14
4 15
3 9 18
7 16 20
5 17
Level-order: 14 4 15 3 9 18 7 16 20 5 17
 There is yet another way of traversing a binary tree that is not related to
recursive traversal procedures discussed previously.
 In level-order traversal, we visit the nodes at each level before proceeding
to the next level.
 At each level, we visit the nodes in a left-to-right order.
14
4 15
3 9 18
7 16 20
5 17
Level-order: 14 4 15 3 9 18 7 16 20 5 17
 How do we do level-order traversal?

 Surprisingly, if we use a queue instead of a stack, we can visit the nodes in
level-order.
 Here is the code for level-order traversal:
 void levelorder(TreeNode<int>* treeNode)
{
Queue<TreeNode<int>* > q;
if( treeNode == NULL ) return;
q.enqueue( treeNode);
while( !q.empty() )
{
treeNode = q.dequeue();
cout << *(treeNode->getInfo()) << " ";
if(treeNode->getLeft() != NULL )
q.enqueue( treeNode->getLeft());
if(treeNode->getRight() != NULL )
q.enqueue( treeNode->getRight());
}
cout << endl;
}
void levelorder(TreeNode<int>* treeNode)
{
 Queue<TreeNode<int>* > q;
while( !q.empty() )
{
}
cout << endl;
}
{
 if( treeNode == NULL ) return;
while( !q.empty() )
{
}
cout << endl;
}
{
 q.enqueue( treeNode);
while( !q.empty() )
{
}
cout << endl;
}
{
 while( !q.empty() )
{
}
cout << endl;
}
{
while( !q.empty() )
{
 treeNode = q.dequeue();
}
cout << endl;
}
{
while( !q.empty() )
{

}
cout << endl;
}
{
while( !q.empty() )
{
}
 cout << endl;
}
14
4 15
3 9 18
7 16 20
5 17
Queue: 14
Output:
14
4 15
3 9 18
7 16 20
5 17
Queue: 4 15
Output: 14
14
4 15
3 9 18
7 16 20
5 17
Queue: 15 3 9
Output: 14 4
14
4 15
3 9 18
7 16 20
5 17
Queue: 3 9 18
Output: 14 4 15
14
4 15
3 9 18
7 16 20
5 17
Queue: 9 18
Output: 14 4 15 3
14
4 15
3 9 18
7 16 20
5 17
Queue: 18 7
Output: 14 4 15 3 9
14
4 15
3 9 18
7 16 20
5 17
Queue: 7 16 20
Output: 14 4 15 3 9 18
14
4 15
3 9 18
7 16 20
5 17
Queue: 16 20 5
Output: 14 4 15 3 9 18 7
14
4 15
3 9 18
7 16 20
5 17
Queue: 20 5 17
Output: 14 4 15 3 9 18 7 16
14
4 15
3 9 18
7 16 20
5 17
Queue: 5 17
Output: 14 4 15 3 9 18 7 16 20
14
4 15
3 9 18
7 16 20
5 17
Queue: 17
Output: 14 4 15 3 9 18 7 16 20 5
14
4 15
3 9 18
7 16 20
5 17
Queue:
Output: 14 4 15 3 9 18 7 16 20 5 17
Storing other Type of Data
 The examples of binary trees so far have been storing integer
data in the tree node.
 This is surely not a requirement. Any type of data can be stored

in a tree node.
 Here, for example, is the C++ code to build a tree with

character strings.
Binary Search Tree with Strings
void wordTree()
{
 TreeNode<char>* root = new TreeNode<char>();
static char* word[] = "babble", "fable", "jacket",
"backup", "eagle","daily","gain","bandit","abandon",
"abash","accuse","economy","adhere","advise","cease",
"debunk","feeder","genius","fetch","chain", NULL};
root->setInfo( word[0] );
for(i=1; word[i]; i++ )

insert(root, word[i] );
inorder( root ); cout << endl;
}
void wordTree()
{
TreeNode<char>* root = new TreeNode<char>();
 static char* word[] = "babble", "fable", "jacket",

}
void wordTree()
{


}
void wordTree()
{

}
void wordTree()
{

 insert(root, word[i] );
}
 void insert(TreeNode<char>* root, char* info)

{
TreeNode<char>* node = new TreeNode<char>(info);
TreeNode<char> *p, *q;
p = q = root;
while( strcmp(info, p->getInfo()) != 0 && q != NULL )
{
p = q;
if( strcmp(info, p->getInfo()) < 0 )
q = p->getLeft();
else
q = p->getRight();
}
void insert(TreeNode<char>* root, char* info)

{
 TreeNode<char>* node = new TreeNode<char>(info);
p = q = root;
{
p = q;
q = p->getLeft();
else
q = p->getRight();
}

{
p = q = root;
 while( strcmp(info, p->getInfo()) != 0 && q != NULL )
{
p = q;
q = p->getLeft();
else
q = p->getRight();
}

{
p = q = root;
 while( strcmp(info, p->getInfo()) != 0 && q != NULL )
{
p = q;
q = p->getLeft();
else
q = p->getRight();
}

{
p = q = root;
{
p = q;

q = p->getLeft();
else
q = p->getRight();
}
 if( strcmp(info, p->getInfo()) == 0 ){

cout << "attempt to insert duplicate: " << *info
<< endl;
delete node;
}
else if( strcmp(info, p->getInfo()) < 0 )
p->setLeft( node );
else
p->setRight( node );
}
if( strcmp(info, p->getInfo()) == 0 ){

<< endl;
delete node;
 }
p->setLeft( node );
else
}
if( strcmp(info, p->getInfo()) == 0 ){

<< endl;
delete node;
}
 p->setLeft( node );
else
}
Output:
abandon
abash
accuse
adhere
advise
babble
backup
bandit
cease
chain
daily
debunk
eagle
economy
fable
feeder
fetch
gain
genius
jacket
abandon
abash
 Notice that the words are sorted in
accuse increasing order when we traversed
adhere
advise the tree in inorder manner.
babble
backup
bandit
cease
chain
daily
debunk
eagle
economy
fable
feeder
fetch
gain
genius
jacket
abandon
abash
adhere
babble
backup
 This should not come as a surprise if
bandit you consider how we built the BST.
cease
chain
daily
debunk
eagle
economy
fable
feeder
fetch
gain
genius
jacket
abandon
abash
adhere
babble
backup
cease
chain  For a given node, values less than the
daily info in the node were all in the left
debunk
eagle subtree and values greater or equal
economy were in the right.
fable
feeder
fetch
gain
genius
jacket
abandon
abash
adhere
babble
backup
cease
chain  For a given node, values less than the
debunk
eagle subtree and values greater or equal
fable
feeder  Inorder prints the left subtree, then the
fetch
gain node finally the right subtree.
genius
jacket
abandon
abash
accuse increasing order when we traversed the
adhere
advise
tree in inorder manner.
babble  This should not come as a surprise if
backup
cease
chain
 For a given node, values less than the
debunk subtree and values greater or equal
eagle
fable
feeder
 Inorder prints the left subtree, then the
fetch node finally the right subtree.
gain
genius
 Building a BST and doing an inorder
jacket traversal leads to a sorting algorithm.
abandon
abash
accuse increasing order when we traversed the
adhere
advise
tree in inorder manner.
babble  This should not come as a surprise if
backup
cease
chain
 For a given node, values less than the
debunk subtree and values greater or equal
eagle
fable
feeder
 Inorder prints the left subtree, then the
fetch node finally the right subtree.
gain
genius
 Building a BST and doing an inorder
jacket traversal leads to a sorting algorithm.
Deleting a node in BST
 As is common with many data structures, the hardest operation is deletion.

 Once we have found the node to be deleted, we need to consider several
possibilities.
 If the node is a leaf, it can be deleted immediately.
 Ifthe node has one child, the node can be

deleted after its parent adjusts a pointer to
bypass the node and connect to inorder
successor.
6
2 8
1 4
3
 The inorder traversal order has to be maintained after the delete.
6 6

2 8 2 8
1 4 1 4
3 3
 The inorder traversal order has to be maintained after the delete.
6 6 6
 
2 8 2 8 2 8
1 4 1 4 1 3
3 3
 The complicated case is when the node to be deleted has both left and right
subtrees.
 The strategy is to replace the data of this node with the smallest data of the
right subtree and recursively delete that node.
Delete(2): locate inorder successor
2 8
1 5
4
Inorder
successor
Delete(2): locate inorder successor
6  Inorder successor will be the left-most

node in the right subtree of 2.
2 8
 The inorder successor will not have a left
child because if it did, that child would be
1 5 the left-most node.
4
Inorder
successor
Delete(2): copy data from inorder successor
6  6
2 8 3 8
1 5 1 5
3 3
4 4
Delete(2): remove the inorder successor
6  6  6
2 8 3 8 3 8
1 5 1 5 1 5
3 3 3
4 4 4
Delete(2)
 6  6
3 8 3 8
1 5 1 5
3 4

CS2133 Lec08

Uploaded by

Copyright:

Available Formats

You might also like

CS2133 Lec08

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CS2133 Lec08

Uploaded by

Copyright:

Available Formats

Lecture No.

17, 9, 14, 5 p->setRight( node );

 Consider the insert(17) in the example tree.

 Each time around the while loop, we did one comparison.

 After the comparison, we moved a level down.

 How many comparison are needed to find out if x is present in

 We do one comparison at each level of the tree until either x

 If the binary tree is built out of n numbers, how many

 For example, for n=1000,000, log2(1000001) is less than 20;

 Or in general, approximately log2(n).

 Compare this with a linked list of 1000,000 numbers. The

 The tree we built for searching for duplicate numbers was a

 BST and its variations play an important role in searching

 Suppose we have a binary tree, ordered (BST) or unordered.

 In what order should we print them?

 Ways to print a 3 node tree:

(4, 14, 15), (4,15,14)

 In case of the general binary tree:

 Three common ways

void preorder(TreeNode<int>* treeNode)

void inorder(TreeNode<int>* treeNode)

void postorder(TreeNode<int>* treeNode)

cout << "inorder: "; inorder( root );

cout << "postorder: "; postorder( root );

 Recall that a stack is used during function calls.

 The caller function places the arguments on the stack and

 Local variables are allocated storage on the call stack.

 Calling a function itself makes no difference as far as the call

Parameters(F) Parameters(F) Parameters(F)

Return address(F) Return address(F) Return address(F)

 We can implement non-recursive versions of the preorder,

void inorder(TreeNode<int>* root)

void inorder(TreeNode<int>* root)

void inorder(TreeNode<int>* root)

 How do we do level-order traversal?

 This is surely not a requirement. Any type of data can be stored

 Here, for example, is the C++ code to build a tree with

for(i=1; word[i]; i++ )

for(i=1; word[i]; i++ )

for(i=1; word[i]; i++ )

for(i=1; word[i]; i++ )

 void insert(TreeNode<char>* root, char* info)

void insert(TreeNode<char>* root, char* info)

void insert(TreeNode<char>* root, char* info)

void insert(TreeNode<char>* root, char* info)

void insert(TreeNode<char>* root, char* info)

 if( strcmp(info, p->getInfo()) == 0 ){

if( strcmp(info, p->getInfo()) == 0 ){

if( strcmp(info, p->getInfo()) == 0 ){

 As is common with many data structures, the hardest operation is deletion.

 Ifthe node has one child, the node can be

 The inorder traversal order has to be maintained after the delete.

 The inorder traversal order has to be maintained after the delete.

Delete(2): locate inorder successor

Delete(2): locate inorder successor

6  Inorder successor will be the left-most

Delete(2): copy data from inorder successor