Grokking Tree Coding Patterns for Interviews

Why trees get their own course

Trees appear in a large share of coding interviews because they are quick to state and easy to get subtly wrong. The usual failures are off-by-one errors on depth, mishandled null children, and choosing a traversal by habit rather than by what the problem needs. Grouping problems by pattern makes those choices explicit.

What it covers

The course page lists 11 chapters, 112 lessons, 117 playgrounds and about 10 hours of study time (September 2026).

• Basics: tree types, BST traversal techniques and BST operations.
• Level order traversal (15 lessons)
• Tree depth (13 lessons)
• Breadth first search and depth first search (11 lessons each)
• Root to leaf paths (19 lessons, the largest chapter)
• Leaf processing: sum of left leaves, deepest leaves sum, leaf-similar trees, deleting leaves with a given value
• Tree views: right, top and bottom views and the boundary of a binary tree, each with its own chapter here
• Comparing two trees
• Serialize and deserialize: including BSTs, N-ary trees and verifying a preorder serialisation

Each pattern starts with an introduction lesson. There are 49 problems graded easy to hard, with algorithm walkthroughs, complexity analysis and code in Python, Java, C++, JavaScript, Go and C#. N-ary trees appear alongside binary ones.

Is it worth it?

As of September 2026 the course page lists a one-time price of $58 for lifetime access, and it is included in the provider's all-courses subscription. It shows a 4.2 rating from about 2,400 ratings.

It extends the tree chapters of Grokking the Coding Interview with the patterns that turn tree questions hard: views, leaf processing, serialisation and N-ary trees.

How long it really takes

Ten hours is the stated reading time. With honest practice, plan about two weeks at an hour a day.

Before you start

You need comfortable recursion and basic queue usage, because nearly every solution here is recursive or uses a queue. Grokking the Art of Recursion for Coding Interviews is the natural lead-in.

How to use it well

• Write the helper signature first. Decide what the recursive helper returns and what it carries down through parameters before writing any body. That is where tree problems are won or lost.
• Test on edge cases: an empty tree, a single node, a tree that is really a linked list.
• Try both traversals on a few problems and compare. Knowing why BFS suits a level question and DFS suits a path question is exactly what interviewers probe.
• Revisit serialise and deserialise at the end. It combines traversal, parsing and recursion, and it is a common hard question.

Best for: candidates whose tree solutions work on the happy path and fail on edge cases, and anyone wanting depth on trees beyond a general course.