chap11.ppt

Data Structures Using C++ 1
Chapter 11
Binary Trees

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

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

Binary Tree

Binary Tree With One Node
The root node of the binary tree = A
LA = empty
RA = empty

Binary Trees With Two Nodes

Various Binary Trees With Three
Nodes

Binary Trees
Following struct defines the node of a binary tree:
template<class elemType>
struct nodeType
{
elemType info;
nodeType<elemType> *llink;
nodeType<elemType> *rlink;
};

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

General Binary Tree

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

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))

Height of a Binary Tree
Function to implement above algorithm:
int height(nodeType<elemType> *p)
{
if(p == NULL)
return 0;
else
return 1 + max(height(p->llink),
height(p->rlink));
}

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

Copy Tree
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

Binary Tree Traversal
• Must start with the root, then
– Visit the node first or
– Visit the subtrees first
• Three different traversals
– Inorder
– Preorder
– Postorder

Traversals
• Inorder
– Traverse the left subtree
– Visit the node
– Traverse the right subtree
• Preorder
– Visit the node

Traversals
• Postorder
– Visit the node

Binary Tree: Inorder Traversal

Binary Tree: Inorder Traversal
void inorder(nodeType<elemType>
*p)
{
if(p != NULL)
{
inorder(p->llink);
cout<<p->info<<” “;
inorder(p->rlink);
}
}

Binary Tree: Traversals
void preorder(nodeType<elemType> *p)
{
if(p != NULL)
{
preorder(p->llink);
preorder(p->rlink);
}
}
void postorder(nodeType<elemType>
*p)
{
if(p != NULL)
{
postorder(p->llink);
postorder(p->rlink);
}
}1

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

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

Binary Search Trees

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

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

Binary Search Tree Analysis
Worst Case: Linear tree

• 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

It follows that:
It is also known that:
Solving Equations (11-1) and (11-2)

Nonrecursive Inorder Traversal

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
}

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;
}
else
{
pop stack into current;
current = current->rlink; //prepare to visit
//the right subtree
}

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;
}

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;
}

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

Perfectly Balanced Binary Tree

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

AVL Trees

Non-AVL Trees

Insertion Into AVL Tree

Insertion Into AVL Trees

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

AVL Tree Rotations

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

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.

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:

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

Chapter Summary
• Binary trees
• Binary search trees
• Recursive traversal algorithms
• Nonrecursive traversal algorithms
• AVL trees

chap11.ppt

Recommended

Recommended

More Related Content

Similar to chap11.ppt

Similar to chap11.ppt (20)

Recently uploaded

Recently uploaded (20)

chap11.ppt