Tree Traversals

Week 8, Tuesday

February 24, 2026

Announcements

Today:

• Implementing Trees in Python
• Tree Traversals

The stained glass tree is a beautiful artistic representation of a tree structure.

Representing Trees in Python

A tree node has a value and children (which are themselves trees!).

from dataclasses import dataclass

@dataclass
class Node:
    value
    left: 'Node' = None   # Another Node (or None)
    right: 'Node' = None  # Another Node (or None)

This is a recursive definition: a Node contains Nodes!

This is our first recursive data structure. The definition refers to itself: a Node has left and right children that are also Nodes (or None for leaves). This mirrors the recursive definition of a tree itself.

Why the quotes around ‘Node’? When Python reads this class definition top-to-bottom, the name Node doesn’t exist yet when we try to use it in the type hint. The quotes make it a “forward reference” — Python defers evaluating it until the class is complete.

Building a Tree

# Build leaf nodes first
leaf_b = Node('b')
leaf_c = Node('c')
leaf_a = Node('a')
leaf_d = Node('d')
leaf_e = Node('e')

# Build internal nodes bottom-up
div_node = Node('/', leaf_b, leaf_c)
minus_node = Node('-', leaf_a, div_node)
times_node = Node('*', leaf_d, leaf_e)

# Build root
root = Node('+', minus_node, times_node)

Or more concisely (inside-out):

root = Node('+',
    Node('-', Node('a'), Node('/', Node('b'), Node('c'))),
    Node('*', Node('d'), Node('e')))

Two ways to build trees: 1. Bottom-up: create leaves, then parents, then root 2. Nested: write the whole structure inline (matches the tree shape visually)

The nested form is harder to read but shows the recursive structure clearly.

Tree Traversal

A scheme for visiting every node in a tree.

This is the “think about a scheme” moment. Don’t constrain the order yet. Ask students: - How would you visit every node exactly once? - What order makes sense? - Is there more than one reasonable order?

The tree represents the expression: (a - (b / c)) + (d * e)

Color coding: - Coral: root (+) - Teal: operators (-, /) - Gold: operator (*) - Dark blue: operands (a, b, c, d, e)

Three Natural Orders

When visiting a node, we have three choices for when to “process” it:

1. Before visiting children
2. Between visiting left and right children
3. After visiting children

These give us three classic traversals.

Preorder Traversal

Preorder: Process the node before its children

preorder(node):
    if node is None: return
    process(node)        # Visit node FIRST
    preorder(node.left)
    preorder(node.right)

Order: + - a / b c * d e

“Pre” = before. We see the root first, then recursively traverse left, then right. This is like reading a book’s table of contents: chapter title, then sections.

Inorder Traversal

Inorder: Process the node between its children

inorder(node):
    if node is None: return
    inorder(node.left)
    process(node)        # Visit node IN THE MIDDLE
    inorder(node.right)

Order: a - b / c + d * e

“In” = in the middle. For expression trees, this gives us the infix notation! For binary search trees (coming next week), this gives us sorted order.

Postorder Traversal

Postorder: Process the node after its children

postorder(node):
    if node is None: return
    postorder(node.left)
    postorder(node.right)
    process(node)        # Visit node LAST

Order: a b c / - d e * +

“Post” = after. We see all descendants before the node itself. This is like evaluating an expression: compute operands before applying operator. Also useful for: deleting a tree (delete children before parent), computing sizes.

Traversal Practice

Preorder: ______________________

Inorder: ______________________

Postorder: ______________________

Answers: - Preorder: 10, 12, 3, 9, 7, 15, 20 - Inorder: 3, 12, 7, 9, 10, 15, 20 - Postorder: 3, 7, 9, 12, 20, 15, 10

The Euler Tour Trick

Walk around the tree, hugging the edges:

• Preorder: Record node when passing on the left
• Inorder: Record node when passing below
• Postorder: Record node when passing on the right

The Euler tour is a mental model for remembering traversal orders. Imagine walking around the tree counterclockwise, starting at the root. You pass each node three times: on the left (pre), below (in), on the right (post).

Traversal Applications

Traversal	When to Use
Preorder	Copy a tree, print directory structure
Inorder	Get sorted order from BST, infix expression
Postorder	Delete a tree, evaluate expression, compute sizes

Postorder: Deleting a Tree

Why postorder for deletion?

def delete_tree(node):
    if node is None:
        return
    delete_tree(node.left)   # Delete left subtree first
    delete_tree(node.right)  # Delete right subtree first
    del node                 # NOW safe to delete this node

Key insight: Must delete children before parent!

If you deleted the parent first, you’d lose access to the children (memory leak). Postorder ensures children are processed before parents.

Preorder: Copying a Tree

Why preorder for copying?

def copy_tree(node):
    if node is None:
        return None
    new_node = Node(node.value)      # Create this node FIRST
    new_node.left = copy_tree(node.left)
    new_node.right = copy_tree(node.right)
    return new_node

Key insight: Must create parent before attaching children!

Actually this is still a form of preorder because we create the node before recursing. The recursive calls build the subtrees, then we attach them.

Level Order Traversal

What if we want to visit by level (top to bottom, left to right)?

This is not recursive in the same way!

We need a queue (coming soon…)

Order: 10, 12, 15, 3, 9, 20, 7

Level order traversal uses BFS (breadth-first search) which requires a queue. We’ll cover this when we discuss queues and BFS in more detail. This connects tree traversal to graph traversal concepts.

Traversal Running Time

For a tree with n nodes:

• Each node is visited exactly once
• Each visit does O(1) work

Total time: O(n) for all traversals

This is true for pre/in/post/level order. We touch every node once, do constant work at each. This is optimal - we can’t visit n nodes in less than O(n) time.

Tuesday Summary

• Preorder: Node, then children (copy, print structure)
• Inorder: Left, node, right (sorted order in BST)
• Postorder: Children, then node (delete, evaluate)
• Level order: Top to bottom, left to right (uses queue)
• All traversals are O(n)

What’s Next

Wednesday: Binary Search Trees

How do we organize a tree so that finding a value is fast?

The key insight: impose an ordering property on the tree!