Welcome to Lesson 10!
Learning Objectives By the end of today's class, you should know... How is a Binary Search Tree (BST) different from a Binary Tree?
 What is the BST Property?
 Why is the BST a recursive structure?
 How do you implement insertion for a BST?
 Why do you need both a helper and wrapper method when you implement the recursive BST methods?
 What is the BigO runtime of insertion, search and removal operations on a BST?
1. The Binary Search Tree ADT
1.1. Defining a BST
 A
Binary Search Tree (BST) is a binary tree for which the following property is
true for all nodes:
The BST Property: 1. Every element in node n's left subtree is less than or equal to the element in n.
2. Every element in n's right subtree is greater than the element in node n.*
(From the Michael Main textbook)
 The following tree is a BST. Verify that the above property is true for this tree.
1.2. BST: A Recursive Structure Remember that the root node is linked to the root nodes of its left and right subtrees.
 These root nodes are in turned linked to the root nodes of other subtrees.
 BSTs are recursive structures because the BST property must hold true for all nodes in the tree and their subtrees.
Image source.
 Examine the tree above. Do all subtrees meet the requirements for a BST?
 Due to the recursive nature of BSTs, we are able to implement most BST operations recursively.
1.3. BST Operations: Insertion
 The BST operations take advantage of the recursive nature of the BST.
 To get a better understanding of the insertion process for a BST, let's look at an example.
 Imagine that we are trying to insert 4 into the BST depicted in the image below.
 At
each root node of a subtree, we need to make a decision. Do we go left?
Do we go right? Or if the node is null, we should insert where we are.
Image source.
 Thus, our process is recursive, as we are making the same decision at each node (i.e. root of a subtree).
1.4. Reflection Activity
 Insert the following values into a BST in the given order: 5 3 6 9 0 2 7 12 4
 How does the tree change if you swap the order of 5 and 9: 9 3 6 5 0 2 7 12 4
1.5. Insertion Pseudocode
 The users of our BST class do not have direct access to any of the nodes in the BST or their data or links.
 However, the fact that we must recursively pass in a Node parameter (the root of the subtree) requires that we use both a helper and wrapper method in the implementation of this method.
 The purpose of the wrapper method is to provide a method that can be called outside of the BST class. This wrapper will in turn call the helper.
 The purpose of the helper method is to implement the recursive insertion algorithm. It will do most of the work of insertion.
 Note that the insertion of duplicates can pose a problem.
 Some implementations of BST insertion do not allow for duplicates
 *With our implementation, duplicates may cause us to amend slightly the BST property to state that all elements in the right subtree must be greater than or equal to the parent.
 Here is the code for the public wrapper method:
public void insert(T data) {
if (root == null) { root = new Node(data);
} else {
insert(data, root);
}
} Here is the pseudocode for the private helper method:
Pseudocode for insert(node, value)
1. Check if the value to insert is smaller than or equal to the data stored at node. 1a. If this is true 1aa. Check if node's left is null
1aaa. If this is true, insert the value at node's left 1b. If the node's left is not NULL 1bb.recursively call the insert method passing it node's left and value 2. Otherwise 2a. Check if the node's right is null
2aa. If this is true, insert the value at node's right 2b. If the node's right is not null 2bb. recursively call the insert method passing it node's right and value 2. Analyzing the Efficiency of BST Operations
2.1. Introduction to Runtime Analysis on Binary Search Tree Operations  The BigO runtime of the BST operations is closely allied to whether or not the tree is balanced.
 Recall that there are several definitions of balanced.
 In this class, we consider a balanced tree to be one that for all nodes in the tree, the following equation is true:
 height_{left}  height_{right} <= 1
 Why is this?
 Consider a binary search tree like this one:
 Now think about searching this tree for a specific value.
 This binary search tree is no different than a linked list.
 Is search efficient on a linked list? We should have seen in Lab 4 that searching a linked list is not efficient.
 Because linked lists do not offer random access of their elements, binary search is not an efficient algorithm for a linked list.
 For binary search trees organized like the one above, search also takes O(n) time, as does insertion and removal.
BST Operations Worst Case: O(n)
 We
are going to see with a more balanced binary search trees, operations such as search, insert and remove are possible in O (log n) time, just like binary search on an array.
BST Operations Average Case: O(log_{2} n)  Why are these operations O(log_{2} n) for a BST?
 Consider search. In the image below, we are searching for the value 4 to determine if it is in the tree:
Image source.
 As in binary search, we continually divide the search space in half until there is only one element:
n > n / 2 > n / 4 > n/ 8... > n/ 2^{k} = 1  Multiply both sides by 2^{k}
n = 2^{k}  Then take the log of both sides:
log_{2} (n) = k  This leaves us with O(log_{2} n).
 Let's walk through an example to verify this works on a balanced BST. What happens if we search for the value 12?
 Insertion
and removal have the same average runtime as search, as both take advantage of the organization of data within the tree.
 However, given a BST, there is no guarantee that the tree will be balanced, or means of enforcing balance  hence the worst case of O(n).
2.2. Comparison of Arrays, Linked Lists and Binary Search Trees Let's compare the average case BigO runtimes of Arrays and Linked Lists to those of the BST when performing 3 common ADT operations:
Array Linked List Binary Search Tree
Search O(log n) O(n) O(log n) Insertion O(n) O(n) O(log n) Deletion O(n) O(n) O(log n)
2.3. Animated BST Efficiency compared to a Linked List (although it says array)
Wrap Up
 Answer the review questions on Canvas for today's lesson
