🌳Trees and Binary Search Trees
Stop confusing BFS with DFS, in-order with pre-order, and balanced with not-quite. Build the tree intuition that lets you draw any node-and-edge problem on a whiteboard and solve five classic interview questions without freezing.
Phase 1Why Trees Beat Lists for Hierarchy
See why trees trade flat lists for fast hierarchies
A tree is a list that grew a hierarchy
6 minA tree is a list that grew a hierarchy
Binary just means at most two children
6 minBinary just means at most two children
A BST trades sortedness for log-time lookup
7 minA BST trades sortedness for log-time lookup
Balance is the difference between O(log n) and O(n)
7 minBalance is the difference between O(log n) and O(n)
Phase 2Coding Insert, Delete, and the Three DFS Traversals
Code insert, delete, and the three DFS traversals
Insert is search that places when it falls off the edge
7 minInsert is search that places when it falls off the edge
In-order traversal of a BST gives you a sorted list
7 minIn-order traversal of a BST gives you a sorted list
Pre-order serializes; post-order destroys safely
7 minPre-order serializes; post-order destroys safely
Delete is three cases — and one of them is sneaky
8 minDelete is three cases — and one of them is sneaky
Level order trades the call stack for a queue
8 minLevel order trades the call stack for a queue
Phase 3BFS vs DFS — Choose by Problem Shape
Pick BFS, DFS, or balanced — by problem shape
The interviewer says 'level' and you reach for a queue
7 minThe interviewer says 'level' and you reach for a queue
Validate a BST without leaking your assumptions
7 minValidate a BST without leaking your assumptions
The LCA problem changes shape between BST and binary tree
8 minThe LCA problem changes shape between BST and binary tree
Why a self-balancing tree is the production answer
8 minWhy a self-balancing tree is the production answer
Phase 4Solve Five Classic Tree Interview Problems
Solve five classic tree interview problems by hand
Walk into the interview ready for five tree problems
20 minWalk into the interview ready for five tree problems
Frequently asked questions
- What's the difference between a tree and a binary search tree?
- This is covered in the “Trees and Binary Search Trees” learning path. Start with daily 5-minute micro-lessons that build from fundamentals to hands-on application.
- When should I use BFS instead of DFS on a tree?
- This is covered in the “Trees and Binary Search Trees” learning path. Start with daily 5-minute micro-lessons that build from fundamentals to hands-on application.
- Why does in-order traversal of a BST give sorted output?
- This is covered in the “Trees and Binary Search Trees” learning path. Start with daily 5-minute micro-lessons that build from fundamentals to hands-on application.
- What makes a binary search tree balanced or unbalanced?
- This is covered in the “Trees and Binary Search Trees” learning path. Start with daily 5-minute micro-lessons that build from fundamentals to hands-on application.
- How do I delete a node from a BST without breaking it?
- This is covered in the “Trees and Binary Search Trees” learning path. Start with daily 5-minute micro-lessons that build from fundamentals to hands-on application.
Related paths
🐍Python Decorators Introduction
Build one mental model for Python decorators that covers closures, argument passing, functools.wraps, and stacking — then ship a working caching or logging decorator from scratch in under 30 lines.
🦀Rust Lifetimes Explained
Stop reading `'a` as line noise and start reading it as scope arithmetic — one failing snippet at a time — until you can thread lifetimes through a small parser or iterator adapter without fighting the borrow checker.
☸️Kubernetes Core Concepts
Stop drowning in 30+ resource types. Build the mental model one primitive at a time -- pods, deployments, services, ingress, config -- then deploy a real app with rolling updates and health checks.
📈Big O Intuition
Stop treating Big O as math you memorized for an interview — build the intuition to spot O(n²) disasters, pick the right data structure without thinking, and rewrite a slow function from O(n²) to O(n) in under five minutes.