2. Data Structures Using C++ 2
Chapter Objectives
• Learn about binary trees
• Explore various binary tree traversal algorithms
• Learn how to organize data in a binary search tree
• Discover how to insert and delete items in a binary
search tree
• Explore nonrecursive binary tree traversal
algorithms
• Learn about AVL (height-balanced) trees
3. Data Structures Using C++ 3
Binary Trees
• Definition: A binary tree, T, is either empty
or such that:
– T has a special node called the root node;
– T has two sets of nodes, LT and RT, called the
left subtree and right subtree of T, respectively;
– LT and RT are binary trees
9. Data Structures Using C++ 9
Binary Trees
Following struct defines the node of a binary tree:
template<class elemType>
struct nodeType
{
elemType info;
nodeType<elemType> *llink;
nodeType<elemType> *rlink;
};
10. Data Structures Using C++ 10
Nodes
• For each node:
– Data is stored in info
– The pointer to the left child is stored in llink
– The pointer to the right child is stored in rlink
12. Data Structures Using C++ 12
Binary Tree Definitions
• Leaf: node that has no left and right
children
• Parent: node with at least one child node
• Level of a node: number of branches on the
path from root to node
• Height of a binary tree: number of nodes no
the longest path from root to node
13. Data Structures Using C++ 13
Height of a Binary Tree
Recursive algorithm to find height of binary
tree:
(height(p) denotes height of binary tree with
root p):
if(p is NULL)
height(p) = 0
else
height(p) = 1 + max(height(p->llink), height(p-
>rlink))
14. Data Structures Using C++ 14
Height of a Binary Tree
Function to implement above algorithm:
template<class elemType>
int height(nodeType<elemType> *p)
{
if(p == NULL)
return 0;
else
return 1 + max(height(p->llink),
height(p->rlink));
}
15. Data Structures Using C++ 15
Copy Tree
• Useful operation on binary trees is to
make identical copy of binary tree
• Use function copyTree when we
overload assignment operator and
implement copy constructor
16. Data Structures Using C++ 16
Copy Tree
template<class elemType>
void copyTree(nodeType<elemType>* &copiedTreeRoot,
nodeType<elemType>* otherTreeRoot)
{
if(otherTreeRoot == NULL)
copiedTreeRoot = NULL;
else
{
copiedTreeRoot = new nodeType<elemType>;
copiedTreeRoot->info = otherTreeRoot->info;
copyTree(copiedTreeRoot->llink, otherTreeRoot->llink);
copyTree(copiedTreeRoot->rlink, otherTreeRoot->rlink);
}
}//end copyTree
17. Data Structures Using C++ 17
Binary Tree Traversal
• Must start with the root, then
– Visit the node first or
– Visit the subtrees first
• Three different traversals
– Inorder
– Preorder
– Postorder
18. Data Structures Using C++ 18
Traversals
• Inorder
– Traverse the left subtree
– Visit the node
– Traverse the right subtree
• Preorder
– Visit the node
– Traverse the left subtree
– Traverse the right subtree
19. Data Structures Using C++ 19
Traversals
• Postorder
– Traverse the left subtree
– Traverse the right subtree
– Visit the node
23. Data Structures Using C++ 23
Implementing Binary Trees:
class binaryTreeType Functions
• Public
– isEmpty
– inorderTraversal
– preorderTraversal
– postorderTraversal
– treeHeight
– treeNodeCount
– treeLeavesCount
– destroyTree
• Private
• copyTree
• Destroy
• Inorder, preorder,
postorder
• Height
• Max
• nodeCount
• leavesCount
24. Data Structures Using C++ 24
Binary Search Trees
• Data in each node
– Larger than the data in its left child
– Smaller than the data in its right child
• A binary search tree,t, is either empty or:
– T has a special node called the root node
– T has two sets of nodes, LT and RT, called the left
subtree and right subtree of T, respectively
– Key in root node larger than every key in left subtree
and smaller than every key in right subtree
– LT and RT are binary search trees
26. Data Structures Using C++ 26
Operations Performed on Binary
Search Trees
• Determine whether the binary search tree is
empty
• Search the binary search tree for a particular
item
• Insert an item in the binary search tree
• Delete an item from the binary search tree
27. Data Structures Using C++ 27
Operations Performed on Binary
Search Trees
• Find the height of the binary search tree
• Find the number of nodes in the binary
search tree
• Find the number of leaves in the binary
search tree
• Traverse the binary search tree
• Copy the binary search tree
29. Data Structures Using C++ 29
Binary Search Tree Analysis
• Theorem: Let T be a binary search tree with n
nodes, where n > 0.The average number of nodes
visited in a search of T is approximately 1.39log2n
• Number of comparisons required to determine
whether x is in T is one more than the number of
comparisons required to insert x in T
• Number of comparisons required to insert x in T
same as the number of comparisons made in
unsuccessful search, reflecting that x is not in T
30. Data Structures Using C++ 30
Binary Search Tree Analysis
It follows that:
It is also known that:
Solving Equations (11-1) and (11-2)
32. Data Structures Using C++ 32
Nonrecursive Inorder Traversal:
General Algorithm
1. current = root; //start traversing the binary tree at
// the root node
2. while(current is not NULL or stack is nonempty)
if(current is not NULL)
{
push current onto stack;
current = current->llink;
}
else
{
pop stack into current;
visit current; //visit the node
current = current->rlink; //move to the
//right child
}
33. Data Structures Using C++ 33
Nonrecursive Preorder Traversal:
General Algorithm
1. current = root; //start the traversal at the root node
2. while(current is not NULL or stack is nonempty)
if(current is not NULL)
{
visit current;
push current onto stack;
current = current->llink;
}
else
{
pop stack into current;
current = current->rlink; //prepare to visit
//the right subtree
}
34. Data Structures Using C++ 34
Nonrecursive Postorder Traversal
1. current = root; //start traversal at root node
2. v = 0;
3. if(current is NULL)
the binary tree is empty
4. if(current is not NULL)
a. push current into stack;
b. push 1 onto stack;
c. current = current->llink;
d. while(stack is not empty)
if(current is not NULL and v is 0)
{
push current and 1 onto stack;
current = current->llink;
}
35. Data Structures Using C++ 35
Nonrecursive Postorder Traversal
(Continued)
else
{
pop stack into current and v;
if(v == 1)
{
push current and 2 onto stack;
current = current->rlink;
v = 0;
}
else
visit current;
}
36. Data Structures Using C++ 36
AVL (Height-balanced Trees)
• A perfectly balanced binary tree is a binary
tree such that:
– The height of the left and right subtrees of the
root are equal
– The left and right subtrees of the root are
perfectly balanced binary trees
38. Data Structures Using C++ 38
AVL (Height-balanced Trees)
• An AVL tree (or height-balanced tree) is a
binary search tree such that:
– The height of the left and right subtrees of the
root differ by at most 1
– The left and right subtrees of the root are AVL
trees
46. Data Structures Using C++ 46
AVL Tree Rotations
• Reconstruction procedure: rotating tree
• left rotation and right rotation
• Suppose that the rotation occurs at node x
• Left rotation: certain nodes from the right subtree of x
move to its left subtree; the root of the right subtree of x
becomes the new root of the reconstructed subtree
• Right rotation at x: certain nodes from the left subtree of x
move to its right subtree; the root of the left subtree of x
becomes the new root of the reconstructed subtree
53. Data Structures Using C++ 53
Deletion From AVL Trees
• Case 1: the node to be deleted is a leaf
• Case 2: the node to be deleted has no right
child, that is, its right subtree is empty
• Case 3: the node to be deleted has no left
child, that is, its left subtree is empty
• Case 4: the node to be deleted has a left
child and a right child
54. Data Structures Using C++ 54
Analysis: AVL Trees
Consider all the possible AVL trees of height h. Let Th be an
AVL tree of height h such that Th has the fewest number of
nodes. Let Thl denote the left subtree of Th and Thr denote the
right subtree of Th. Then:
where | Th | denotes the number of nodes in Th.
55. Data Structures Using C++ 55
Analysis: AVL Trees
Suppose that Thl is of height h – 1 and Thr is of height h – 2.
Thl is an AVL tree of height h – 1 such that Thl has the fewest
number of nodes among all AVL trees of height h – 1. Thr is
an AVL tree of height h – 2 that has the fewest number of
nodes among all AVL trees of height h – 2. Thl is of the form
Th -1 and Thr is of the form Th -2. Hence:
56. Data Structures Using C++ 56
Analysis: AVL Trees
Let Fh+2 = |Th | + 1. Then:
Called a Fibonacci sequence; solution to Fh is given by:
Hence
From this it can be concluded that
57. Data Structures Using C++ 57
Chapter Summary
• Binary trees
• Binary search trees
• Recursive traversal algorithms
• Nonrecursive traversal algorithms
• AVL trees