Bab 5

Binary Trees

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 2

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

Binary Tree

Data Structures Using Java

Binary Tree with One Node

The root node of the binary tree = A

LA = empty
RA = empty

Data Structures Using Java

Binary Tree with Two Nodes

Data Structures Using Java

Binary Tree with Two Nodes

Data Structures Using Java

Various Binary Trees with Three Nodes

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

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

10

General Binary Tree

Data Structures Using Java

11

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

12

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

13

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

14

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

15

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

16

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

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

Data Structures Using Java

19

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

Data Structures Using Java

20

Binary Tree: Inorder Traversal

Data Structures Using Java

21

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

22

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

23

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

24

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

25

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 26

Binary Search Trees

Data Structures Using Java

27

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

28

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

29

Binary Search Tree: Analysis

Data Structures Using Java

30

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

31

Binary Search Tree: Analysis

It follows that:

It is also known that:

Solving Equations (10-1) and (10-2)

Data Structures Using Java

32

Nonrecursive Inorder Traversal

Data Structures Using Java

33

Nonrecursive Inorder Traversal: General Algorithm

1. 2. //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 } current = root;

Data Structures Using Java

34

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

35

Nonrecursive Postorder Traversal

1. 2. 3.
4.

current = root; //start traversal at root node v = 0; if(current is NULL) the binary tree is empty 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; }

Data Structures Using Java 36

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

Data Structures Using Java

37

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

38

Perfectly Balanced Binary Tree

Data Structures Using Java

39

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

40

AVL Trees

Data Structures Using Java

41

Non-AVL Trees

Data Structures Using Java

42

Insertion Into AVL Tree

Data Structures Using Java

43

Insertion Into AVL Trees

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

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 48

AVL Tree Rotations

Data Structures Using Java

49

AVL Tree Rotations

Data Structures Using Java

50

AVL Tree Rotations

Data Structures Using Java

51

AVL Tree Rotations

Data Structures Using Java

52

AVL Tree Rotations

Data Structures Using Java

53

AVL Tree Rotations

Data Structures Using Java

54

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

55

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

56

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

57

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 58

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

59

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

Data Structures Using Java

60