Binary Trees

1
Chapter 10

• Binary Trees

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

4
Binary Tree
5
Binary Tree with One Node
The root node of the binary tree A LA
empty RA empty
6
Binary Tree with Two Nodes
7
Binary Tree with Two Nodes
8
Various Binary Trees with Three Nodes
9
Binary Trees

• Following class defines the node of a binary
  tree
• protected class BinaryTreeNode
• DataElement info
• BinaryTreeNode llink
• BinaryTreeNode rlink

10
Nodes

• For each node
• Data is stored in info
• The reference to the left child is stored in
  llink
• The reference to the right child is stored in
  rlink

11
General Binary Tree
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
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.rl
  ink))

14
Height of a Binary Tree

• Method to implement above algorithm
• private int height(BinaryTreeNode p)
• if(p NULL)
• return 0
• else
• return 1 max(height(p.llink),
• height(p.rlink))

15
Copy Tree

• Useful operation on binary trees is to make
  identical copy of binary tree
• Method copy useful in implementing copy
  constructor and method copyTree

16
Method copy

• BinaryTreeNode copy(BinaryTreeNode otherTreeRoot)
• BinaryTreeNode temp
• if(otherTreeRoot null)
• temp null
• else
• temp new BinaryTreeNode()
• temp.info otherTreeRoot.info.getCopy()
• temp.llink copy(otherTreeRoot.llink)
• temp.rlink copy(otherTreeRoot.rlink)
• return temp
• //end copy

17
Method copyTree

• public void copyTree(BinaryTree otherTree)
• if(this ! otherTree) //avoid self-copy
• root null
• if(otherTree.root ! null) //otherTree is
  //nonempty
• root copy(otherTree.root)

18
Binary Tree Traversal

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

19
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

20
Traversals

• Postorder
• Traverse the left subtree
• Traverse the right subtree
• Visit the node

21
Binary Tree Inorder Traversal
22
Binary Tree Inorder Traversal
private void inorder(BinaryTreeNode p) if(p
! NULL) inorder(p.llink)
System.out.println(p.info )
inorder(p.rlink)
23
Binary Tree Preorder Traversal
private void preorder(BinaryTreeNode p)
if(p ! NULL) System.out.println(p.info
) preorder(p.llink)
preorder(p.rlink)
24
Binary Tree Postorder Traversal
private void postorder(BinaryTreeNode p)
if(p ! NULL) postorder(p.llink)
postorder(p.rlink)
System.out.println(p.info )
25
Implementing Binary Trees class BinaryTree
methods

• isEmpty
• inorderTraversal
• preorderTraversal
• postorderTraversal
• treeHeight
• treeNodeCount
• treeLeavesCount
• destroyTree
• copyTree

• Copy
• Inorder
• Preorder
• postorder
• Height
• Max
• nodeCount
• leavesCount

26
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

27
Binary Search Trees
28
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

29
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

30
Binary Search Tree Analysis
31
Binary Search Tree Analysis

• Theorem Let T be a binary search tree with n
  nodes, where n gt 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

32
Binary Search Tree Analysis

• It follows that

It is also known that
Solving Equations (10-1) and (10-2)
33
Nonrecursive Inorder Traversal
34
Nonrecursive Inorder Traversal General Algorithm

• current root //start traversing the binary
  tree at
• // the root node
• 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

35
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

36
Nonrecursive Postorder Traversal

• current root //start traversal at root node
• v 0
• if(current is NULL)
• the binary tree is empty
• if(current is not NULL)
• push current into stack
• push 1 onto stack
• current current.llink
• while(stack is not empty)
• if(current is not NULL and v is 0)
• push current and 1 onto stack
• current current.llink

37
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

38
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

39
Perfectly Balanced Binary Tree
40
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

41
AVL Trees
42
Non-AVL Trees
43
Insertion Into AVL Tree
44
Insertion Into AVL Trees
45
Insertion Into AVL Trees
46
Insertion Into AVL Trees
47
Insertion Into AVL Trees
48
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

49
AVL Tree Rotations
50
AVL Tree Rotations
51
AVL Tree Rotations
52
AVL Tree Rotations
53
AVL Tree Rotations
54
AVL Tree Rotations
55
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

56
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.
57
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
58
Analysis AVL Trees
Let Fh2 Th 1. Then
Called a Fibonacci sequence solution to Fh is
given by
Hence
From this it can be concluded that
59
Programming Example Video Store (Revisited)

• In Chapter 4,we designed a program to help a
  video store automate its video rental process.
• That program used an (unordered) linked list to
  keep track of the video inventory in the store.
• Because the search algorithm on a linked list is
  sequential and the list is fairly large, the
  search could be time consuming.
• If the binary tree is nicely constructed (that
  is, it is not linear), then the search algorithm
  can be improved considerably.
• In general, item insertion and deletion in a
  binary search tree is faster than in a linked
  list.
• We will redesign the video store program so that
  the video inventory can be maintained in a binary
  tree.

60
Chapter Summary

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