Binary Search Trees

1
Binary Search Trees

• CS 308 Data Structures

2
What is a binary tree?

• Property1 each node can have up to two successor
  nodes (children)
• The predecessor node of a node is called its
  parent
• The "beginning" node is called the root (no
  parent)
• A node without children is called a leaf

3
Owner Jake
Manager Chef
Brad Carol Waitress
Waiter Cook
Helper Joyce
Chris
Max Len
4
Owner Jake
Manager Chef
Brad Carol Waitress
Waiter Cook
Helper Joyce
Chris
Max Len
5
What is a binary tree? (cont.)

• Property2 a unique path exists from the root to
  every other node

6
Some terminology

• Ancestor of a node any node on the path from the
  root to that node
• Descendant of a node any node on a path from the
  node to the last node in the path
• Level (depth) of a node number of edges in the
  path from the root to that node
• Height of a tree number of levels (warning some
  books define it as levels - 1)

7
A Tree Has Levels
Owner Jake
Manager Chef
Brad Carol Waitress
Waiter Cook
Helper Joyce
Chris
Max Len
LEVEL 0
8
Owner Jake
Manager Chef
Brad Carol Waitress
Waiter Cook
Helper Joyce
Chris
Max Len
9
Level Two
Owner Jake
Manager Chef
Brad Carol Waitress
Waiter Cook
Helper Joyce
Chris
Max Len
LEVEL 2
10
A Subtree
Owner Jake
Manager Chef
Brad Carol Waitress
Waiter Cook
Helper Joyce
Chris
Max Len
LEFT SUBTREE OF ROOT NODE
11
Another Subtree
Owner Jake
Manager Chef
Brad Carol Waitress
Waiter Cook
Helper Joyce
Chris
Max Len
RIGHT SUBTREE OF ROOT NODE
12
What is the of nodes N of a full tree with
height h?
The max nodes at level is
l0
l1
lh-1
using the geometric series
13
What is the height h of a full tree with N nodes?

• The max height of a tree with N nodes is N (same
  as a linked list)
• The min height of a tree with N nodes is log(N1)

14
(No Transcript)
15
Searching a binary tree

• (1) Start at the root
• (2) Search the tree level by level, until you
  find the element you are searching for (O(N)
  time in worst case)
• Is this better than searching a linked list?
  

No ---gt O(N)
16
Binary Search Trees

• Binary Search Tree Property The value stored at
  a node is greater than the value stored at its
  left child and less than the value stored at its
  right child
• Thus, the value stored at the root of a subtree
  is greater than any value in its left subtree and
  less than any value in its right subtree!!

17
(No Transcript)
18
Searching a binary search tree

1. (1) Start at the root
2. (2) Compare the value of the item you are
   searching for with the value stored at the root
3. (3) If the values are equal, then item found
   otherwise, if it is a leaf node, then not found

19
Searching a binary search tree (cont.)

• (4) If it is less than the value stored at the
  root, then search the left subtree
• (5) If it is greater than the value stored at the
  root, then search the right subtree
• (6) Repeat steps 2-6 for the root of the subtree
  chosen in the previous step 4 or 5
• Is this better than searching a linked list?

Yes !! ---gt O(logN)
20
Tree node structure
templateltclass ItemTypegt struct
TreeNode ItemType info TreeNode
left TreeNode right
21
Binary Search Tree Specification

• include ltfstream.hgt
•  
• templateltclass ItemTypegt
• struct TreeNode
•  
• enum OrderType PRE_ORDER, IN_ORDER, POST_ORDER
•  
• templateltclass ItemTypegt
• class TreeType
• public
• TreeType()
• TreeType()
• TreeType(const TreeTypeltItemTypegt)
• void operator(const TreeTypeltItemTypegt)
• void MakeEmpty()
• bool IsEmpty() const
• bool IsFull() const
• int NumberOfNodes() const

(continues)
22
Binary Search Tree Specification
(cont.)

• void RetrieveItem(ItemType, bool found)
• void InsertItem(ItemType)
• void DeleteItem(ItemType)
• void ResetTree(OrderType)
• void GetNextItem(ItemType, OrderType,
  bool)
• void PrintTree(ofstream) const
• private
• TreeNodeltItemTypegt root
•  

23
Function NumberOfNodes

• Recursive implementation
• nodes in a tree
• nodes in left subtree nodes in right
  subtree 1
• What is the size factor?
• Number of nodes in the tree we are examining
• What is the base case?
• The tree is empty
• What is the general case?
• CountNodes(Left(tree)) CountNodes(Right(tree))
  1

24
Function NumberOfNodes (cont.)

• templateltclass ItemTypegt
• int TreeTypeltItemTypegtNumberOfNodes() const
• return CountNodes(root)
•  
• templateltclass ItemTypegt
• int CountNodes(TreeNodeltItemTypegt tree)
• if (tree NULL)
• return 0
• else
• return CountNodes(tree-gtleft)
  CountNodes(tree-gtright) 1

25

• Lets consider the first few steps

26
Function RetrieveItem
27
Function RetrieveItem

• What is the size of the problem?
• Number of nodes in the tree we are examining
• What is the base case(s)?
• When the key is found
• The tree is empty (key was not found)
• What is the general case?
• Search in the left or right subtrees

28
Function RetrieveItem (cont.)

• template ltclass ItemTypegt
• void TreeTypeltItemTypegt RetrieveItem(ItemType
  item,bool found)
• Retrieve(root, item, found)
•  
• templateltclass ItemTypegt
• void Retrieve(TreeNodeltItemTypegt tree,ItemType
  item,bool found)
• if (tree NULL) // base case 2
• found false
• else if(item lt tree-gtinfo)
• Retrieve(tree-gtleft, item, found)
• else if(item gt tree-gtinfo)
• Retrieve(tree-gtright, item, found)
• else // base case 1
• item tree-gtinfo
• found true

29
Function InsertItem

• Use the binary search tree property to insert the
  new item at the correct place

30
Function InsertItem (cont.)

• Implementing insertion using recursion

Insert 11
31
Function InsertItem (cont.)

• What is the size of the problem?
• Number of nodes in the tree we are examining
• What is the base case(s)?
• The tree is empty
• What is the general case?
• Choose the left or right subtree

32
Function InsertItem (cont.)

• templateltclass ItemTypegt
• void TreeTypeltItemTypegtInsertItem(ItemType
  item)
• Insert(root, item)
•  
• templateltclass ItemTypegt
• void Insert(TreeNodeltItemTypegt tree, ItemType
  item)
• if(tree NULL) // base case
• tree new TreeNodeltItemTypegt
• tree-gtright NULL
• tree-gtleft NULL
• tree-gtinfo item
• else if(item lt tree-gtinfo)
• Insert(tree-gtleft, item)
• else
• Insert(tree-gtright, item)

33
Function InsertItem (cont.)
Insert 11
34
Does the order of inserting elements into a tree
matter?

• Yes, certain orders produce very unbalanced
  trees!!
• Unbalanced trees are not desirable because search
  time increases!!
• There are advanced tree structures
  (e.g.,"red-black trees") which guarantee balanced
  trees

35
Does the order of inserting elements into a tree
matter? (cont.)
36
Function DeleteItem

• First, find the item then, delete it
• Important binary search tree property must be
  preserved!!
• We need to consider three different cases 
• (1) Deleting a leaf
• (2) Deleting a node with only one child
• (3) Deleting a node with two children

37
(1) Deleting a leaf
38
(2) Deleting a node with only one child
39
(3) Deleting a node with two children
40
(3) Deleting a node with two children (cont.)

• Find predecessor (it is the rightmost node in the
  left subtree)
• Replace the data of the node to be deleted with
  predecessor's data
• Delete predecessor node

41
Function DeleteItem (cont.)

• What is the size of the problem?
• Number of nodes in the tree we are examining
• What is the base case(s)?
• Key to be deleted was found
• What is the general case?
• Choose the left or right subtree

42
Function DeleteItem (cont.)

• templateltclass ItemTypegt
• void TreeTypeltItmeTypegtDeleteItem(ItemType
  item)
• Delete(root, item)
•  
• templateltclass ItemTypegt
• void Delete(TreeNodeltItemTypegt tree, ItemType
  item)
• if(item lt tree-gtinfo)
• Delete(tree-gtleft, item)
• else if(item gt tree-gtinfo)
• Delete(tree-gtright, item)
• else
• DeleteNode(tree)

43
Function DeleteItem (cont.)

• template ltclass ItemTypegt
• void DeleteNode(TreeNodeltItemTypegt tree)
• ItemType data
• TreeNodeltItemTypegt tempPtr
•  
• tempPtr tree
• if(tree-gtleft NULL) //right child
• tree tree-gtright
• delete tempPtr
• else if(tree-gtright NULL) // left child
• tree tree-gtleft
• delete tempPtr
• else
• GetPredecessor(tree-gtleft, data)
• tree-gtinfo data
• Delete(tree-gtleft, data)

0 or 1 child
0 or 1 child
2 children
44
Function DeleteItem (cont.)

• templateltclass ItemTypegt
• void GetPredecessor(TreeNodeltItemTypegt tree,
  ItemType data)
• while(tree-gtright ! NULL)
• tree tree-gtright
• data tree-gtinfo

45
Tree Traversals

• There are mainly three ways to traverse a tree
• Inorder Traversal
• Postorder Traversal
• Preorder Traversal

46
Inorder Traversal A E H J M T Y
Visit second
tree
T
E
A
H
M
Y
Visit left subtree first
Visit right subtree last
47
Inorder Traversal

• Visit the nodes in the left subtree, then visit
  the root of the tree, then visit the nodes in the
  right subtree
• Inorder(tree)
•  
• If tree is not NULL
• Inorder(Left(tree))
• Visit Info(tree)
• Inorder(Right(tree))
• (Warning "visit" means that the algorithm does
  something with the values in the node, e.g.,
  print the value)

48
Postorder Traversal A H E M Y T J
Visit last
tree
T
E
A
H
M
Y
Visit left subtree first
Visit right subtree second
49
Postorder Traversal

• Visit the nodes in the left subtree first, then
  visit the nodes in the right subtree, then visit
  the root of the tree
• Postorder(tree)
• If tree is not NULL
• Postorder(Left(tree))
• Postorder(Right(tree))
• Visit Info(tree)

50
Preorder Traversal J E A H T M Y
Visit first
tree
T
E
A
H
M
Y
Visit left subtree second
Visit right subtree last
51
Preorder Traversal

• Visit the root of the tree first, then visit the
  nodes in the left subtree, then visit the nodes
  in the right subtree
• Preorder(tree)
• If tree is not NULL
• Visit Info(tree)
• Preorder(Left(tree))
• Preorder(Right(tree))

52
Tree Traversals
53
Function PrintTree

• We use "inorder" to print out the node values
• Why?? (keys are printed out in ascending order!!)
• Hint use binary search trees for sorting !!

A D J M Q R T
54
Function PrintTree (cont.)

• void TreeTypePrintTree(ofstream outFile)
• Print(root, outFile)
•  
• templateltclass ItemTypegt
• void Print(TreeNodeltItemTypegt tree, ofstream
  outFile)
• if(tree ! NULL)
• Print(tree-gtleft, outFile)
• outFile ltlt tree-gtinfo
• Print(tree-gtright, outFile)
•  
• (see textbook for overloading ltlt and gtgt)

55
Class Constructor

• templateltclass ItemTypegt
• TreeTypeltItemTypegtTreeType()
• root NULL

56
Class Destructor
How should we delete the nodes of a tree?
57
Class Destructor (contd)

• Delete the tree in a "bottom-up" fashion
• Postorder traversal is appropriate for this !!
• TreeTypeTreeType()
• Destroy(root)
•  
• void Destroy(TreeNodeltItemTypegt tree)
• if(tree ! NULL)
• Destroy(tree-gtleft)
• Destroy(tree-gtright)
• delete tree

58
Copy Constructor
How should we create a copy of a tree?
59
Copy Constructor (contd)

• templateltclass ItemTypegt
• TreeTypeltItemTypegtTreeType(const
  TreeTypeltItemTypegt
• originalTree)
• CopyTree(root, originalTree.root)
•  
• templateltclass ItemType)
• void CopyTree(TreeNodeltItemTypegt copy,
  TreeNodeltItemTypegt originalTree)
• if(originalTree NULL)
• copy NULL
• else
• copy new TreeNodeltItemTypegt
• copy-gtinfo originalTree-gtinfo
• CopyTree(copy-gtleft, originalTree-gtleft)
• CopyTree(copy-gtright, originalTree-gtright)

preorder
60
ResetTree and GetNextItem

• The user is allowed to specify the tree traversal
  order
• For efficiency, ResetTree stores in a queue the
  results of the specified tree traversal
• Then, GetNextItem, dequeues the node values from
  the queue

61
ResetTree and GetNextItem (cont.)(specification
file)

• enum OrderType PRE_ORDER, IN_ORDER, POST_ORDER
•  
• templateltclass ItemTypegt
• class TreeType
• public
• // same as before
• private
• TreeNodeltItemTypegt root
• QueTypeltItemTypegt preQue
• QueTypeltItemTypegt inQue
• QueTypeltItemTypegt postQue

new private data
62
ResetTree and GetNextItem (cont.)

• templateltclass ItemTypegt
• void PreOrder(TreeNodeltItemTypegt,
  QueTypeltItemTypegt)
•  
• templateltclass ItemTypegt
• void InOrder(TreeNodeltItemTypegt,
  QueTypeltItemTypegt)
•  
• templateltclass ItemTypegt
• void PostOrder(TreeNodeltItemTypegt,
  QueTypeltItemTypegt)
•  

63
ResetTree and GetNextItem (cont.)

• templateltclass ItemTypegt
• void PreOrder(TreeNodeltItemTypegttree,
  QueTypeltItemTypegt preQue)
• if(tree ! NULL)
• preQue.Enqueue(tree-gtinfo)
• PreOrder(tree-gtleft, preQue)
• PreOrder(tree-gtright, preQue)
•  

64
ResetTree and GetNextItem (cont.)

• templateltclass ItemTypegt
• void InOrder(TreeNodeltItemTypegttree,
  QueTypeltItemTypegt inQue)
• if(tree ! NULL)
• InOrder(tree-gtleft, inQue)
• inQue.Enqueue(tree-gtinfo)
• InOrder(tree-gtright, inQue)

65
ResetTree and GetNextItem (cont.)

• templateltclass ItemTypegt
• void PostOrder(TreeNodeltItemTypegttree,
  QueTypeltItemTypegt postQue)
• if(tree ! NULL)
• PostOrder(tree-gtleft, postQue)
• PostOrder(tree-gtright, postQue)
• postQue.Enqueue(tree-gtinfo)

66
The function ResetTree

• templateltclass ItemTypegt
• void TreeTypeltItemTypegtResetTree(OrderType
  order)
• switch(order)
• case PRE_ORDER PreOrder(root, preQue)
• break
• case IN_ORDER InOrder(root, inQue)
• break
• case POST_ORDER PostOrder(root, postQue)
• break

67
The function GetNextItem

• templateltclass ItemTypegt
• void TreeTypeltItemTypegtGetNextItem(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

68
Iterative Insertion and Deletion

• See textbook

69
Comparing Binary Search Trees to Linear Lists
Big-O Comparison Big-O Comparison Big-O Comparison Big-O Comparison
Operation Binary Search Tree Array-based List Linked List
Constructor O(1) O(1) O(1)
Destructor O(N) O(1) O(N)
IsFull O(1) O(1) O(1)
IsEmpty O(1) O(1) O(1)
RetrieveItem O(logN) O(logN) O(N)
InsertItem O(logN) O(N) O(N)
DeleteItem O(logN) O(N) O(N)
70
Exercises

• 1-3, 8-18, 21, 22, 29-32