1. Data Structures Using Java
Chapter 10
Binary Trees
Data Structures Using Java

2. Data Structures Using Java
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
Data Structures Using Java

3. Data Structures Using Java
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
Data Structures Using Java

4. Data Structures Using Java
Binary Tree
Data Structures Using Java

5. Binary Tree with One Node
The root node of the binary tree = A
LA = empty
RA = empty
Data Structures Using Java

6. Binary Tree with Two Nodes
Data Structures Using Java

7. Binary Tree with Two Nodes
Data Structures Using Java

8. Various Binary Trees with Three Nodes
Data Structures Using Java

9. Data Structures Using Java
Binary Trees
Following class defines the node of a binary tree:
protected class BinaryTreeNode {
DataElement info;
BinaryTreeNode llink;
BinaryTreeNode rlink; }
Data Structures Using Java

10. Data Structures Using Java
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
Data Structures Using Java

11. Data Structures Using Java
General Binary Tree
Data Structures Using Java

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
Data Structures Using Java

13. Data Structures Using Java
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))
Data Structures Using Java

14. Data Structures Using Java
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)); }
Data Structures Using Java

15. Data Structures Using Java
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
Data Structures Using Java

16. Data Structures Using Java
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
Data Structures Using Java

17. Data Structures Using Java
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); }
Data Structures Using Java

18. Data Structures Using Java
Binary Tree Traversal
Must start with the root, then
Visit the node first or
Visit the subtrees first
Three different traversals
Inorder
Preorder
Postorder
Data Structures Using Java

19. Data Structures Using Java
Traversals
Inorder
Traverse the left subtree
Visit the node
Traverse the right subtree
Preorder
Data Structures Using Java

20. Data Structures Using Java
Traversals
Postorder
Traverse the left subtree
Traverse the right subtree
Visit the node
Data Structures Using Java

21. Binary Tree: Inorder Traversal
Data Structures Using Java

22. Binary Tree: Inorder Traversal
private void inorder(BinaryTreeNode p) {
if(p != NULL)
inorder(p.llink);
System.out.println(p.info + “ “);
inorder(p.rlink); }
Data Structures Using Java

23. Binary Tree: Preorder Traversal
private void preorder(BinaryTreeNode p) {
if(p != NULL)
System.out.println(p.info + “ “);
preorder(p.llink);
preorder(p.rlink); }
Data Structures Using Java

24. Binary Tree: Postorder Traversal
private void postorder(BinaryTreeNode p) {
if(p != NULL)
postorder(p.llink);
postorder(p.rlink);
System.out.println(p.info + “ “); }
Data Structures Using Java

25. Implementing Binary Trees: class BinaryTree methods
isEmpty
inorderTraversal
preorderTraversal
postorderTraversal
treeHeight
treeNodeCount
treeLeavesCount
destroyTree
copyTree
Copy
Inorder
Preorder
postorder
Height
Max
nodeCount
leavesCount
Data Structures Using Java

26. Data Structures Using Java
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
Data Structures Using Java

27. Data Structures Using Java
Binary Search Trees
Data Structures Using Java

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
Data Structures Using Java

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
Data Structures Using Java

30. Binary Search Tree: Analysis
Data Structures Using Java

31. 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
Data Structures Using Java

32. Binary Search Tree: Analysis
It follows that:
It is also known that:
Solving Equations (10-1) and (10-2)
Data Structures Using Java

33. Nonrecursive Inorder Traversal
Data Structures Using Java

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
Data Structures Using Java

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
Data Structures Using Java

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; }
Data Structures Using Java

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; }
visit current;
Data Structures Using Java

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
Data Structures Using Java

39. Perfectly Balanced Binary Tree
Data Structures Using Java

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
Data Structures Using Java

41. Data Structures Using Java
AVL Trees
Data Structures Using Java

42. Data Structures Using Java
Non-AVL Trees
Data Structures Using Java

43. Insertion Into AVL Tree
Data Structures Using Java

44. Insertion Into AVL Trees
Data Structures Using Java

45. Insertion Into AVL Trees
Data Structures Using Java

46. Insertion Into AVL Trees
Data Structures Using Java

47. Insertion Into AVL Trees
Data Structures Using Java

48. Data Structures Using Java
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
Data Structures Using Java

49. Data Structures Using Java
AVL Tree Rotations
Data Structures Using Java

50. Data Structures Using Java
AVL Tree Rotations
Data Structures Using Java

51. Data Structures Using Java
AVL Tree Rotations
Data Structures Using Java

52. Data Structures Using Java
AVL Tree Rotations
Data Structures Using Java

53. Data Structures Using Java
AVL Tree Rotations
Data Structures Using Java

54. Data Structures Using Java
AVL Tree Rotations
Data Structures Using Java

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
Data Structures Using Java

56. Data Structures Using Java
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.
Data Structures Using Java

57. Data Structures Using Java
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:
Data Structures Using Java

58. Data Structures Using Java
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
Data Structures Using Java

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.
Data Structures Using Java

60. Data Structures Using Java
Chapter Summary
Binary trees
Binary search trees
Recursive traversal algorithms
Nonrecursive traversal algorithms
AVL trees
Data Structures Using Java