Chapter 8 Binary Search Trees. 2 Goals Define and use the following terminology: binary tree root...

Chapter 8

Binary Search Trees

2

Goals

• Define and use the following terminology: binary tree root

descendant subtree binary search tree parent level

ancestor child height

• Define a binary search tree at the logical level

• Show what a binary search tree would look like after a series of insertions and deletions

3

Goals

• Implement the following binary search tree algorithms in C++

Inserting an element

Deleting an element

Retrieving an element

Modifying an element

Copying a tree

Traversing a tree in preorder, inorder, postorder

4

Goals

• Discuss the Big-O efficiency of a given binary search tree operation

• Describe an algorithm for balancing a binary search tree

• Show how a binary tree can be represented in an array, with implicit positional links between the elements

• Define the terms full binary tree and complete binary tree

5

Owner Jake

Manager Chef Brad Carol

Waitress Waiter Cook Helper Joyce Chris Max Len

Trees

Jake’s Pizza Shop

6

Owner Jake

Manager Chef Brad Carol

Waitress Waiter Cook Helper Joyce Chris Max Len

ROOT NODE

Trees

7

Owner Jake

Manager Chef Brad Carol

Waitress Waiter Cook Helper Joyce Chris Max Len

LEAF NODES

Trees

8

Owner Jake

Manager Chef Brad Carol

Waitress Waiter Cook Helper Joyce Chris Max Len

LEVEL 0

Trees

9

Owner Jake

Manager Chef Brad Carol

Waitress Waiter Cook Helper Joyce Chris Max Len

LEVEL 1

Trees

10

Owner Jake

Manager Chef Brad Carol

Waitress Waiter Cook Helper Joyce Chris Max Len

LEVEL 2

Trees

11

Owner Jake

Manager Chef Brad Carol

Waitress Waiter Cook Helper Joyce Chris Max Len

LEFT SUBTREE OF ROOT NODE

Trees

12

Owner Jake

Manager Chef Brad Carol

Waitress Waiter Cook Helper Joyce Chris Max Len

RIGHT SUBTREE OF ROOT NODE

Trees

13

Trees

Binary Tree

A structure with a unique starting node (the root), in which each node is capable of having two child nodes and a unique path exists from the root to every other node

Root

The top node of a tree structure; a node with no parent

Leaf Node

A tree node that has no children

14

Trees

LevelDistance ofa node fromthe root

HeightThe maximumlevel

15

Trees

Why isthis not atree

?

16

Trees

Q

V

T

K S

A E

L

How many leaf nodes?

17

Trees

Q

V

T

K S

A E

L

Q has how manydescendant?

18

Trees

Q

V

T

K S

A E

L

S has how manyancestors?

19

Trees

How many different binary trees can be madefrom 2 nodes? 4 nodes? 6 nodes?

20

Binary Search Trees

Binary Search Trees

A binary tree in which the key value in any node is greater than the key value in the left child and any of its children and less than the key value in the right child and any of its children

A BST is a binary tree with the search property

21

Binary Search Trees

Eachnode is

theroot of asubtree

22

Recursive Implementation

23

Recursive Count

Let’s start by counting the number of nodes in

a tree

Size?

Base cases(s)?

General case(s)?

24

Recursive Count

Count (Version 1)

if (Left(tree) is NULL) AND (Right(tree) is NULL)

return 1

else

return Count (Left(tree)) + Count(Right(tree)) + 1

Apply tothese trees

25

Recursive Count

Count (Version 2)if (left(tree) is NULL) AND (Right(tree) is NULL)

return 1else if (Left(tree) is NULL)

return Count(Right(tree)) + 1else if (Right(tree) is NULL)

return Count(Left(tree)) + 1else return Count(Left(tree)) + Count(Right(tree)) + 1

Apply to an empty tree

26

Recursive Count

Count (Version 3)if (tree is NULL)

// Version 2

Stop

Count (Version 4)if (tree is NULL)

return 0else

return Count(Left(tree)) + Count(Right(tree)) + 1

27

Recursive Count

int TreeType() const{ return Count(root);)int Count(TreeNode* tree){ if (tree == NULL) return 0 else return Count(tree->left) + Count(tree->right) + 1;}

Why do we need two functions?

28

Recursive Search

‘J’

‘E’

‘A’ ‘H’

‘T’

‘M’

‘K’

‘V’

‘P’ ‘Z’‘D’

‘Q’‘L’‘B’

‘S’Are ‘D’, ‘Q’, and ‘N’ in the tree?

29

Recursive Search

Retrieve(tree, item, found)

Size?

Base case(s)?

General case(s)?

30

Recursive Search

void Retrieve(TreeNode* tree, ItemType& item,

bool& found){ if (tree == NULL) found = false; else if (item < tree->info) Retrieve(tree->left, item, found); else if (item > tree->info) Retrieve(tree->right, item, found); else { item = tree->info; found = true; }}

31

Shape depends on the order of item insertion

Insert the elements ‘J’ ‘E’ ‘F’ ‘T’ ‘A’ in that order

The first value inserted is always put in the root

Shape of BST

‘J’

32

Thereafter, each value to be inserted

compares itself to the value in the root node

moves left it is less or

moves right if it is greater

When does the process stop?

Shape of BST

‘J’

‘E’

33

Trace path to insert ‘F’

Shape of BST

‘J’

‘E’

‘F’

34

Trace path to insert ‘T’

Shape of BST

‘J’

‘E’

‘F’

‘T’

35

Trace path to insert ‘A’

Shape of BST

‘J’

‘E’

‘F’

‘T’

‘A’

36

Now build tree by inserting ‘A’ ‘E’ ‘F’ ‘J’ ‘T’ in that order

Shape of BST

And the moral is?

37

Recursive Insertion

Insert an item into a tree

Where does each new node get inserted?

Insert(tree, item)if (tree is NULL)

Get a new nodeSet right and left to NULLSet info to item

38

Recursive Insertion

39

Recursive Insertion

40

Recursive Insertion

How mustthe tree

bepassed?

41

Recursive Insertionvoid Insert(TreeNode*& tree, ItemType item){ if (tree == NULL) {// Insertion place found. tree = new TreeNode; tree->right = NULL; tree->left = NULL; tree->info = item; } else if (item < tree->info) Insert(tree->left, item); else Insert(tree->right, item); }

42

Recursive DeletionDelete ‘Z’

43

Recursive Deletion

Delete ‘R’

44

Recursive Deletion

Delete ‘Q’

45

Recursive Deletion

Can you summarize the three deletion cases?

46

Recursive Deletion

DeleteItem(tree, item)

if (Left(tree) is NULL) AND (Right(tree) is NULL)

Set tree to NULL

else if Left(tree) is NULL

Set tree to Right(tree)

else if Right(tree) is NULL

Set tree to Left(tree)

else

Find predecessor

Set Info(tree) to Info(predecessor)

Delete predecessor

47

Recursive Deletion

void Delete(TreeNode*& tree, ItemType item){ if (item < tree->info) Delete(tree->left, item); else if (item > tree->info) Delete(tree->right, item); else DeleteNode(tree); // Node found}

48

Recursive Deletionvoid DeleteNode(TreeNode*& tree){ ItemType data; TreeNode* tempPtr; tempPtr = tree; if (tree->left == NULL) { tree = tree->right; delete tempPtr; } else if (tree->right == NULL){ tree = tree->left; delete tempPtr;} els{ GetPredecessor(tree->left, data); tree->info = data; Delete(tree->left, data);}}

49

Recursive Deletion

void GetPredecessor(TreeNode* tree, ItemType& data)

{ while (tree->right != NULL) tree = tree->right; data = tree->info;}

Why is the code not recursive?

50

Recursive Deletion

51

Printing the Tree

Apply same algorithm to each tree

What is the order of the output?

52

Printing the Tree

PrintTree operation

Size?

Base case(s)?

General case(s)?

53

Printing the Tree

void PrintTree(TreeNode* tree,

std::ofstream& outFile)

{

if (tree != NULL)

{

PrintTree(tree->left, outFile);

outFile << tree->info;

PrintTree(tree->right, outFile);

}

}

Is thatall

thereis?

54

A QuestionDo we need a destructor?

55

Copying a Tree

CopyTree(copy, originalTree)

if (originalTree is NULL)

Set copy to NULL

else

Set copy to new node

Set Info(copy) to Info(originalTree)

CopyTree(Left(copy), Left(originalTree))

CopyTree(Right(copy), Right(originalTree))

How must copy be passed?How must originalTree be passed?

56

Copying a Treevoid CopyTree(TreeNode*& copy, const TreeNode* originalTree){ if (originalTree == NULL) copy = NULL; else { copy = new TreeNode; copy->info = originalTree->info; CopyTree(copy->left, originalTree->left); CopyTree(copy->right, originalTree->right); }}

57

Traversals

Inorder(tree)if tree is not NULL

Inorder(Left(tree))Visit Info(tree)Inorder(Right(tree))

PostOrder(tree)if tree is not NULL

Postorder(Left(tree))Postorder(Right(tree))Visit Info(tree)

PreOrder(tree)if tree is not NULL

Visit Info(tree)Preorder(Left(tree))

Preorder(Right(tree))

alphabetic order

destructor (why?)

expression evaluation

58

Traversals

Each nodeis visited

three times

59

Traversals

60

Iterator

Approach The client program passes a parameter to ResetTree

and GetNextItem indicating which of the three traversals to use

ResetTree generates a queues of node contents in the indicated order

GetNextItem processes the node contents from the appropriate queue: inQue, preQue, postQue

61

Iteratorvoid TreeType::ResetTree(OrderType order)// Calls function to create a queue of the tree // elements in the desired order.{ switch (order) { case PRE_ORDER : PreOrder(root, preQue); break; case IN_ORDER : InOrder(root, inQue); break; case POST_ORDER: PostOrder(root, postQue); break; }}

62

void TreeType::GetNextItem(ItemType& item, OrderType order,bool& finished){ finished = false; switch (order) { case PRE_ORDER : preQue.Dequeue(item); if (preQue.IsEmpty()) finished = true; break; case IN_ORDER : inQue.Dequeue(item); if (inQue.IsEmpty()) finished = true; break; case POST_ORDER: postQue.Dequeue(item); if (postQue.IsEmpty()) finished = true; break; }}

Iterator

63

Iterative Versions

FindNode(tree, item, nodePtr, parentPtr)Set nodePtr to treeSet parentPtr to NULLSet found to false while more elements to search AND NOT found

if item < Info(nodePtr)Set parentPtr to nodePtrSet nodePtr to Left(nodePtr)

else if item > Info(nodePtr)Set parentPtr to nodePtrSet nodePtr to Right(nodePtr)

elseSet found to true

64

Iterative Versions

InsertItem

Create a node to contain the new item

Find the insertion place

Attach new node

Find the insertion place

FindNode(tree, item, nodePtr, parentPtr);

65

Iterative Versions

Insert 13

66

Iterative Versions

67

Iterative Versions

AttachNewNode

if item < Info(parentPtr)

Set Left(parentPtr) to newNode

else

Set Right(parentPtr) to newNode

See aproblem

?

68

Iterative Version

AttachNewNode(revised)

if parentPtr equals NULL

Set tree to newNode

else if item < Info(parentPtr)

Set Left(parentPtr) to newNode

else

Set Right(parentPtr) to newNode

69

Iterative Version

void TreeType::DeleteItem(ItemType item)

{ TreeNode* nodePtr; TreeNode* parentPtr; FindNode(root, item, nodePtr,

parentPtr); if (nodePtr == root) DeleteNode(root); else if (parentPtr->left == nodePtr) DeleteNode(parentPtr->left); else DeleteNode(parentPtr->right);}

Why not parentPtr?

Why not nodePtr?

70

Iterative Version

parentPtr and nodePtr are external; parentPtr->left is internal

71

Recursion VS Iteration

Compare versions of Tree algorithms

Is the depth of recursion relatively shallow?

Is the recursive solution shorter or cleaner?

Is the recursive version much less efficient?

72

Nonlinked Representation

What is the mapping into the index?

73

Nonlinked Representation

For any node tree.nodes[index]its left child is in tree.nodes[index*2 + 1]right child is in tree.nodes[index*2 + 2]its parent is in tree.nodes[(index - 1)/2]

Can you determine which nodes are leaf nodes?

74

Nonlinked Representation

Full Binary Tree

A binary tree in which all of the leaves are on the same level and every nonleaf node has two children

75

Nonlinked Representation

Complete Binary Tree

A binary tree that is either full or full through the next-to-last level, with the leaves on the last level as far to the left as possible

76

Nonlinked Representation

77

Nonlinked Representation

A techniquefor storing

a non-complete

tree