binary trees

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:

template<class elemType>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

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


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– Traverse the left subtree– Traverse the right subtree


Traversals

• Postorder– Traverse the left subtree– Traverse the right subtree– 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 AnalysisWorst Case: Linear tree


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


Binary Search Tree Analysis

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 node2. 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 node2. 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 }


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;

}


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

binary trees

Documents

binary trees data structures

node data structures

avl tree data structures

height of binary tree

nodes data structures

rlink data structures

binary search tree

nonavl trees data structures