# Lecture 10: Trees

## October 10, 2016

## data structures |

Starting this lecture at 6:40 btw. 30 minutes of nothingness before.

## Trees

- Trees are a bunch of nodes
- Need to have references to child nodes
- Very likely going to iterate across children, not necessarily jump to a specific one.
- You could do this with a LinkedList but there’s an easier way
- To iterate through children, go to
`firstChild`

and then iterate through using`nextSibling`

```
class TreeNode<T> {
T data;
TreeNode<T> nextSibling; // Similar to LinkedList
TreeNode<T> firstChild; // Another LinkedList type structure to children
}
```

Pre-order traversal: evaluate the node first, then evaluate the children. Post-order: evaluate the children first, then the node.

## Tree Traversal

A pre-order tree traversal via `listAll`

```
// Pseudo code
private void listAll(int depth) {
printName(depth); // Print name of object
if(isDirectory()) {
for each file c in this directory (for each child) {
c.listAll(depth + 1);
}
}
}
public void listAll() {
listAll(0); // Initial call for root node calls actual recursive method
}
```

## Tree Types

- Full Binary Tree
- ?

- Complete Binary Tree
- Last row is filled up from left to right but not all the way

- Perfect Binary Tree
- A complete binary tree with the last row all filled up

Need to think about the number of nodes in a tree given the height..

A perfect binary tree has `2^(h + 1) - 1`

nodes.

Btw, know what “proof by induction” means.

### Proof by Induction

#### Base Case

- 2^(0 + 1) - 1 = 1
- 2^(1 + 1) - 1 = 3

Assume for perfect trees of height `1`

through `k`

this holds.

So now we need to prove that this works for a tree of height `k + 1`

.

A tree of height `k`

will have `2^(k + 1) - 1`

nodes.

Now copy that tree and we have two identical trees.

Now add a root node and point to the root nodes of those two initial trees.

So now we just need to add up the nodes.

`2 * (2^(k + 1) - 1) + 1`

`2^((k + 1) + 1) - 2 + 1`

`2^((k + 1) + 1) - 1`

## QUESTION ONE ON THE MIDTERM WILL ESSENTIALLY BE THIS BUT ON ANOTHER

CHARACTERISTIC OF THE BINARY TREE

## Expression Tree

Tree will be represented by a full binary tree. In a binary tree, there is something on the “left” and something on the “right” so there is some implicit order.

Operators are interior nodes. Operands are leaf nodes.

Example:

3 + (2 * 5)

+ 3 * 2 5

Does the root node of an expression tree have to be an operand? Nope.

Interior nodes must be operators.

Leaf nodes must be operands?

Look at the ExpressionNode class…

```
public class ExprNode {
Op data; // either operator or operand
ExprNode left;
ExprNode right;
}
```