1. Trees
Lecture 12
CS2110 – Spring 2018

2. Important Announcements
A4 is out now and due two weeks from today. Have fun, and start early!
There are slots available for lunch with the professors:
link from Piazza
Recitation 6: Iterator and Iterable
Watch the tutorials!
Quiz due on Monday (yes, that's the day before the prelim, sorry)

3. Data Structures
There are different ways of storing data, called data structures
Each data structure has operations that it is good at and operations that it is bad at
For any application, you want to choose a data structure that is good at the things you do often

4. Example Data Structures
add(val x)
lookup(int i)
Array
Linked List
𝑂(𝑛)
𝑂(1) 2 1 3
𝑂(1)
𝑂(𝑛) 2 1 3

5. The Problem of Search
Search is the problem of finding an element in a data structure when you don't know where it is stored
example applications: DB indexing, process scheduling (CFS Linux), set/map/dictionary (C++)

6. Example Data Structures
add(val x)
lookup(int i)
Array
Linked List
search(val x)
𝑂(𝑛)
𝑂(1)
𝑂(𝑛) 2 1 3
𝑂(1)
𝑂(𝑛)
𝑂(𝑛) 2 1 3

7. Tree Singly linked list: Node object pointer int value Today: trees! 21
Node object
pointer
int value 4 1 2
Today: trees!

8. Tree Overview Tree: data structure with nodes, similar to linked list5 4 7 8 9 2 5 4 7 8 9 2
Tree: data structure with nodes, similar to linked list
Each node may have zero or more successors (children)
Each node has exactly one predecessor (parent) except the root, which has none
All nodes are reachable from root
A tree
Not a tree 5 4 7 8 5 6 8
If you draw a bunch of circles and arrows, and you want to know whether you have drawn a tree…
Not a tree
A tree

9. Tree Terminology the root of the tree (no parents) child of MW P J D N H B S
child of M
child of M
the leaves of the tree
(no children)

10. Tree Terminology M G W P J D N H B S
ancestors of B
descendants of W

11. Tree Terminology M G W P J D N H B S
subtree of M

12. Tree Terminology A node’s depth is the length of the path to the root.
A tree’s (or subtree’s) height is he length of the longest path from the root to a leaf. M G W P J D N H B S
Depth 1, height 2.
Depth 3, height 0.

13. Tree Terminology
Multiple trees:
a forest. G W P J D N H B S

14. Class for general tree nodes
class GTreeNode<T> {
private T value;
private List<GTreeNode<T>> children;
//appropriate constructors, getters,
//setters, etc. } 5 4 2
Parent contains a list of its children
General tree 7 8 9 7 8 3 1

15. Binary Trees
A binary tree is a particularly important kind of tree where every node as at most two children.
In a binary tree, the two children are called the left and right children. 5 4 7 8 9 2
Not a binary tree
(a general tree) 5 4 7 8 2
Binary tree

16. Binary trees were in A1! You have seen a binary tree in A1.
A PhD object has one or two advisors. (Confusingly, the advisors are the “children.”)
David Gries
Friedrich Bauer
Georg Aumann
Fritz Bopp
Fritz Sauter
Erwin Fues
Heinrich Tietze
Constantin Carathodory

17. Class for binary tree node
class TreeNode<T> { private T value; private TreeNode<T> left, right; /** Constructor: one-node tree with datum x */ public TreeNode (T v) { value= v; left= null; right= null;} /** Constr: Tree with root value x, left tree l, right tree r */ public TreeNode (T v, TreeNode<T> l, TreeNode<T> r) { value= v; left= l; right= r; }
Either might be null if the subtree is empty.
Binary trees are a special case of general trees, but they are *so common* that we will sometimes just say “tree” when we really mean “binary tree.”
more methods: getValue, setValue, getLeft, setLeft, etc.

18. A Tree is a Recursive Thing
A binary tree is either null or an object consisting of a value, a left binary tree, and a right binary tree.

19. Looking at trees recursively
Binary tree 2
Right subtree
(also a binary tree) 9 8 3 5 7
Left subtree,
which is a binary tree too

20. Looking at trees recursively
a binary tree

21. Looking at trees recursively
value
right
subtree
left
subtree

22. Looking at trees recursively
value

23. A Recipe for Recursive Functions
Base case:
If the input is “easy,” just solve the problem directly.
Recursive case:
Get a smaller part of the input (or several parts).
Call the function on the smaller value(s).
Use the recursive result to build a solution for the full input.

24. Recursive Functions on Binary Trees
Base case:
empty tree (null)
or, possibly, a leaf
Recursive case:
Call the function on each subtree.
Use the recursive result to build a solution for the full input.

25. Comparing Data Structures
add(val x)
lookup(int i)
Array
Linked List
search(val x)
𝑂(𝑛)
𝑂(1)
𝑂(𝑛) 2 1 3
𝑂(1)
𝑂(𝑛)
𝑂(𝑛)
Binary Tree 2 1 3 2 1 3
𝑂(1)
𝑂(𝑛)
𝑂(𝑛)

26. Binary Search Tree (BST)
A binary search tree is a binary tree that is ordered and has no duplicate values. In other words, for every node:
All nodes in the left subtree have values that are less than the value in that node, and
All values in the right subtree are greater. 2 3 7 9 5 8
< 5
> 5
A BST is the key to making search way faster.

27. Building a BST To insert a new item: Pretend to look for the item
Put the new node in the place where you fall off the tree

28. Building a BST
january

29. Building a BST
january

30. Building a BST
january
february

31. Building a BST
january
february

32. Building a BST
january
february

33. Building a BST
january
march
february

34. Building a BST
january
february
march

35. Building a BST
january
april
february
march

36. Building a BST
january
april
february
march

37. Building a BST
january
february
march
april

38. Building a BST
january
february
march
april

39. Building a BST january february march april june may august july
september
december
october
november

40. Printing contents of BST
/** Print BST t in alpha order */
private static void print(TreeNode<T> t) {
if (t== null) return;
print(t.left);
System.out.print(t.value);
print(t.right); }
Because of ordering rules for a BST, it’s easy to print the items in alphabetical order
Recursively print left subtree
Print the node
Recursively print right subtree
show code

41. Binary Search Tree (BST)2 3 7 9 5 8
Compare binary tree to binary search tree:
boolean searchBT(n, v):
if n==null, return false
if n.v == v, return true
return searchBST(n.left, v)
|| searchBST(n.right, v)
boolean searchBST(n, v):
if n==null, return false
if n.v == v, return true
if v < n.v
return searchBST(n.left, v)
else
return searchBST(n.right, v)
Here's the thing: if the tree is perfectly balanced, so there's the same amount of stuff on either side of any node, then this is *asymptotically* very fast. The height of the tree is log_2 n. And you only have to traverse *at most* the height of the tree! So searching is O(log n) if the tree is balanced.
2 recursive calls
1 recursive call

42. Comparing Data Structures
add(val x)
lookup(int i)
Array
Linked List
search(val x)
𝑂(𝑛)
𝑂(1)
𝑂(𝑛) 2 1 3
𝑂(1)
𝑂(𝑛)
𝑂(𝑛)
Binary Tree
BST 2 1 3 1 2 3
𝑂(1)
𝑂(𝑛)
𝑂(𝑛) 2 1 3
𝑂(𝑑𝑒𝑝𝑡ℎ)
𝑂(𝑑𝑒𝑝𝑡ℎ)
𝑂(𝑑𝑒𝑝𝑡ℎ)

43. Inserting in Alphabetical Order
april

44. Inserting in Alphabetical Order
april

45. Inserting in Alphabetical Order
april
august

46. Inserting in Alphabetical Order
april
august

47. Inserting in Alphabetical Order
april
august
december

48. Inserting in Alphabetical Order
april
august
december
february
january

49. Insertion Order Matters
A balanced binary tree is one where the two subtrees of any node are about the same size.
Searching a binary search tree takes O(h) time, where h is the height of the tree.
In a balanced binary search tree, this is O(log n).
But if you insert data in sorted order, the tree becomes imbalanced, so searching is O(n).

50. Things to think about What if we want to delete data from a BST?
A BST works great as long as it’s balanced.
There are kinds of trees that can automatically keep themselves balanced as you insert things!
jan
feb
mar
apr
jun
may
jul