Validate Binary Search Tree
Given the root of a binary tree, determine if it is a valid BST. A valid BST requires that all nodes in the left subtree are strictly less than the root, and all nodes in the right subtree are strictly greater.
This is a premium problem.
Unlock Validate Binary Search Tree with both full courses, DSA and System Design, and every other premium problem.
Problem
Given the root of a binary tree, determine if it is a valid binary search tree (BST).
Input
The root of a binary tree.
Output
`true` if the tree is a valid BST, `false` otherwise.
Examples
Input: root = [2,1,3]
Output: true
Input: root = [5,1,4,null,null,3,6]
Output: false
Node 4 is in the right subtree of 5, so it must be > 5. But 4 < 5.
The brute-force approach
For each node, collect all values in its left subtree and right subtree. Check that all left values are < node.val and all right values are > node.val.
def get_all(node):
if not node: return []
return [node.val] + get_all(node.left) + get_all(node.right)
def is_valid(node):
if not node: return True
left_vals = get_all(node.left)
right_vals = get_all(node.right)
if any(v >= node.val for v in left_vals): return False
if any(v <= node.val for v in right_vals): return False
return is_valid(node.left) and is_valid(node.right)O(n²) — repeated subtree collection for each node.
Spotting the pattern
This is a Tree Traversal problem. The key question to ask yourself:
Why is checking left.val < node.val < right.val at each node NOT enough to validate a BST? What counter-example would pass that check but fail the real BST property?
Answering that is where it clicks, and it's exactly what the guided walkthrough below builds with you: the pattern reasoning, a progressive hint ladder that never spoils the answer, a row-by-row dry run, the optimized solution, and an in-browser editor to run your code against real test cases.
Unlock the full guided solution
The Tree Traversal walkthrough for Validate Binary Search Tree: the progressive hint ladder, a row-by-row dry run, the optimized code, and an in-browser runner, plus both full courses, DSA and System Design, and every other premium problem.
Already finished Big-O and Hash Maps free? This picks up right where the path leads: same format, harder patterns, the ones that show up in every FAANG-style screen.
What you get
- ✓The full DSA course: concept lessons, drills, graded tests, and cold-read capstones for every pattern
- ✓The full System Design course: 20 building-block units for the design round, included at no extra cost
- ✓Stop going blank on algorithm problems. The hint ladder walks you to the answer without spoiling it.
- ✓Actually internalize the trace: dry runs walk state row by row so it clicks before you write a line
- ✓Know when to reach for each pattern. Every problem names the trigger so you spot it next time.
- ✓Write and run JS or Python in the browser with real test cases on every problem
- ✓Access every new problem, unit, and pattern guide as they ship weekly
“This app finally made it click. I tried NeetCode, CTCI, and YouTube for years and still couldn't solve Two Sum. The beginner mental models for the patterns are genuinely so helpful. THANK YOU.”
Full access
$49 / year
or $9 / month
Now includes a C++ runner alongside JavaScript and Python.
LeetCode Premium is $159/year and doesn't teach you anything.
Less than one Udemy course, with guided problems instead of passive lectures.
One extra month of job searching costs more than a full year here.
- ✓Both courses, every unit: DSA + System Design
- ✓All 150 problems across 33 patterns, plus every new one
- ✓New problems and units weekly
- ✓Cancel anytime
Cancel anytime. Not useful within 7 days? Email for a full refund. Secured by Stripe.