chapter 19: binary trees java programming: program design including data structures program design...

Chapter 19: Binary TreesChapter 19: Binary Trees

Java Programming: Java Programming:

Program Design Including Data Program Design Including Data StructuresStructures

Java Programming: Program Design Including Data Structures 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


Binary Trees

A binary 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 LT and RT are binary trees

A binary tree can be shown pictorially


Binary Trees (continued)

Figure 19-1 Binary tree



Figure 19-6 Various binary trees with three nodes


Binary Trees (continued) You can write a class that represents each node in a

binary tree Called BinaryTreeNode

Instance variables of the class BinaryTreeNode info: stores the information part of the node lLink: points to the root node of the left subtree rLink: points to the root node of the right subtree



Figure 19-7 UML class diagram of the class BinaryTreeNode and the outer-inner class relationship



Figure 19-8 Binary tree



A leaf is a node in a tree with no children Let U and V be two nodes in a binary tree

U is called the parent of V if there is a branch from U to V

A path from a node X to a node Y is a sequence of nodes X0, X1, ..., Xn such that:

X = X0,Xn = Y

Xi-1 is the parent of Xi for all i = 1, 2, ..., n



Length of a path The number of branches on that path

Level of a node The number of branches on the path from the root to

the node Height of a binary tree

The number of nodes on the longest path from the root to a leaf



Method heightprivate int height(BinaryTreeNode<T> p)

{

if (p == null)

return 0;

else

return 1 + Math.max(height(p.lLink), height(p.rLink));

}


Copy Tree

Method copyTreeprivate BinaryTreeNode<T> copyTree

(BinaryTreeNode<T> otherTreeRoot)

{

BinaryTreeNode<T> temp;

if (otherTreeRoot == null)

temp = null;

else

{

temp = (BinaryTreeNode<T>) otherTreeRoot.clone();

temp.lLink = copyTree(otherTreeRoot.lLink);

temp.rLink = copyTree(otherTreeRoot.rLink);

}

return temp;

}//end copyTree


Binary Tree Traversal

Item insertion, deletion, and lookup operations require that the binary tree be traversed

Commonly used traversals Inorder traversal Preorder traversal Postorder traversal


Inorder Traversal

Binary tree is traversed as follows: Traverse left subtree Visit node Traverse right subtree


Inorder Traversal (continued)

Method inOrderprivate void inorder(BinaryTreeNode<T> p)

{

if (p != null)

{

inorder(p.lLink);

System.out.print(p + “ “);

inorder(p.rLink);

}

}


Preorder Traversal

Binary tree is traversed as follows: Visit node Traverse left subtree Traverse right subtree


Preorder Traversal (continued)

Method preOrderprivate void preorder(BinaryTreeNode<T> p)

{

if (p != null)

{


preorder(p.lLink);

preorder(p.rLink);

}

}


Postorder Traversal

Binary tree is traversed as follows: Traverse left subtree Traverse right subtree Visit node


Postorder Traversal (continued)

Method postOrderprivate void postorder(BinaryTreeNode<T> p)

{

if (p != null)

{

postorder(p.lLink);

postorder(p.rLink);


}

}


Implementing Binary Trees

Figure 19-11 UML class diagram of the interface BinaryTreeADT


Implementing Binary Trees (continued)

Figure 19-12 UML class diagram of the class BinaryTree


Implementing Binary Trees (continued)

Method clonepublic Object clone()

{

BinaryTree<T> copy = null;

try

{

copy = (BinaryTree<T>) super.clone();

}

catch (CloneNotSupportedException e)

{

return null;

}

if (root != null)

copy.root = copyTree(root);

return copy;

}


Binary Search Trees

To search for an item in a normal binary tree, you must traverse entire tree until item is found Search process will be very slow Similar to searching in an arbitrary linked list

Binary search tree Data in each node is

Larger than the data in its left child Smaller than the data in its right child


Binary Search Trees (continued)

Figure 19-14 Binary search tree


Binary Search Trees (continued)

Figure 19-15 UML class diagram of the class BinarySearchTree and the inheritance hierarchy


Search

Searches tree for a given item General steps

Compare item with info in root node If they are the same, stop the search

If item is smaller than info in root node Follow link to left subtree

Otherwise Follow link to right subtree


Insert

Inserts a new item into a binary search tree General steps

Search tree and find the place where new item is to be inserted Search algorithm is similar to method search

Insert new item Duplicate items are not allowed


Delete

Deletes item from a binary search tree After deleting items, resulting tree must be a binary

search tree General steps

Search the tree for the item to be deleted Searching algorithm is similar to method search

Delete item


Delete (continued)

Delete operation has four cases Case 1: Node to be deleted is a leaf Case 2: Node to be deleted has no left subtree Case 3: Node to be deleted has no right subtree Case 4: Node to be deleted has nonempty left and

right subtrees search left subtree of the node to be deleted to find its immediate predecessor


Binary Search Tree: Analysis

Performance depends on shape of the tree If tree shape is linear, performance is the same as for

a linked list Average number of nodes visited

1.39log2n = O(log2n)

Average number of key comparisons



Nonrecursive Binary Tree Traversal Algorithms

Traversal algorithms Inorder Preorder Postorder


Nonrecursive Inorder Traversal

Method nonRecursiveInTraversalpublic void nonRecursiveInTraversal()

{

LinkedStackClass<BinaryTreeNode<T> > stack

= new LinkedStackClass<BinaryTreeNode<T> >();

BinaryTreeNode<T> current;

current = root;

while ((current != null) || (!stack.isEmptyStack()))

if (current != null)

{

stack.push(current);

current = current.lLink;

}


Nonrecursive Inorder Traversal (continued)

else

{

current = (BinaryTreeNode<T>) stack.peek();

stack.pop();

System.out.print(current.info + “ “);

current = current.rLink;

}

System.out.println();

}


Nonrecursive Preorder Traversal

General algorithmcreate stack

current = root;

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

}


Nonrecursive Postorder Traversal

General algorithm Mark left subtree of node as visited Visit left subtree and return to node Mark right subtree of node as visited Visit right subtree and return to node Visit node


An Iterator to a Binary Tree

You can create an iterator for a binary tree Iterator can traverse tree using

Inorder traversal Preorder traversal Postorder traversal


AVL (Height-Balanced) Trees Search performance depends on shape of the tree

You want the tree to be balanced AVL (height-balanced) tree

Resulting binary search tree is nearly balanced Perfectly balanced binary search tree

Heights of the left and right subtrees are equal Left and right subtrees are perfectly balanced binary

trees


AVL (Height-Balanced) Trees(continued)

Figure 19-24 Perfectly balanced binary tree


AVL (Height-Balanced) Trees (continued)

AVL tree: A binary search tree where Heights of left and right subtrees differs by at most 1 Left and right subtrees are AVL trees

Balance factor Difference between height of right subtree and height

of left subtree


AVL (Height-Balanced) Trees (continued)

Figure 19-25 Perfectly balanced binary tree


Insertion into AVL Trees

General steps Search AVL tree to find insertion point Insert new item

Duplicate items are not allowed Rebalance tree (if needed)


Insertion into AVL Trees (continued)

Figure 19-27 AVL tree before inserting 90



Figure 19-28 Binary search tree of Figure 19-27 after inserting 90; nodes other than 90 show their balance factors before insertion



Figure 19-29 AVL tree of Figure 19-27 after inserting 90 and adjusting the balance factors


AVL Tree Rotations

Reconstruction procedure Types of rotations

Left rotation Nodes from right subtree move to left subtree Root of right subtree becomes root of reconstructed

subtree Right rotation

Nodes from left subtree move to right subtree Root of left subtree becomes root of reconstructed

subtree


AVL Tree Rotations (continued)

Figure 19-39 Left rotation at a



Figure 19-39 Right rotation at b


AVL Tree Rotations (continued) Method rotateToLeftprivate AVLNode<T> rotateToLeft(AVLNode<T> root)

{

AVLNode<T> p; //reference variable to the root of the right subtree of root

if (root == null)

System.err.println(“Error in the tree.”);

else

if (root.rLink == null)

System.err.println(“Error in the tree: “

+ “No right subtree to rotate.”);

else

{

p = root.rLink;

root.rLink = p.lLink; //the left subtree of p becomes the right

//subtree of root

p.lLink = root;

root = p; //make p the new root node

}

return root;

}//end rotateToLeft


AVL Tree Rotations (continued) Method rotateToRightprivate AVLNode<T> rotateToRight(AVLNode<T> root)

{

AVLNode<T> p; //reference variable to the root of the

//left subtree of root

if (root == null)

System.err.println(“Error in the tree.”);

else

if (root.lLink == null)

System.err.println(“Error in the tree: “

+ “No left subtree to rotate.”);

else

{

p = root.lLink;

root.lLink = p.rLink; //the right subtree of p

//becomes the left subtree of root

p.rLink = root;

root = p; //make p the new root node

}

return root;

}//end rotateToRight



Figure 19-44 AVL tree after inserting 40



Deletion from AVL Trees General steps

Find node to be deleted Delete node

Four cases arise: Node to be deleted is a leaf Node to be deleted has no right child Node to be deleted has no left child Node to be deleted has both children


Height of AVL tree with n nodes (worst case)


Time to manipulate an AVL tree in the worst case is no more than 44% of optimum time

Average search time of an AVL tree is about 4% more than the optimum

Analysis: AVL Trees


Programming Example: Video Store (Revisited)

Program in Chapter 16 used a linked list to keep track of video inventory Search could be time consuming

Modify program to use a binary tree instead Insertion and deletion in a binary search tree is faster

than in a linked list


Chapter Summary

Binary trees Every node has only two children

Left subtree Right subtree

Binary tree traversal Inorder Preorder Postorder


Chapter Summary (continued) Binary search trees

Each node is greater than elements in its left subtree and less than elements in its right subtree

AVL (height-balanced) trees Binary search tree Heights of left and right subtrees differs by at most 1 Left and right subtrees of the root node are AVL trees

chapter 19: binary trees java programming: program design including data structures program design...

Documents