DSA Trainer
← All problems
PremiumTree TraversalEasy

Same Tree

Asked at:AmazonGoogle

Given the roots of two binary trees, return true if the trees are structurally identical and every corresponding node has the same value.

This is a premium problem.

Unlock Same Tree with both full courses, DSA and System Design, and every other premium problem.

Problem

Given the roots of two binary trees p and q, write a function to check if they are the same or not.

Input

The roots of two binary trees, `p` and `q`. Each is represented as a level-order array.

Output

A boolean: `true` if the two trees are identical in structure and values, `false` otherwise.

Examples

Input: p = [1,2,3], q = [1,2,3]

Output: true

Both trees have the same structure and values.

Input: p = [1,2], q = [1,null,2]

Output: false

Both have value 2, but in p it's the left child; in q it's the right child.

Input: p = [1,2,1], q = [1,1,2]

Output: false

Root is the same, but children are swapped.

The brute-force approach

Serialize both trees to strings (level-order) and compare the strings.

def serialize(node):
    if not node:
        return 'null'
    return f'{node.val},{serialize(node.left)},{serialize(node.right)}'

return serialize(p) == serialize(q)

Serializing is O(n) time and O(n) space, and it works. But the direct recursive comparison is also O(n) and more natural, and it short-circuits as soon as it finds a mismatch, without building any strings.

Time: O(n)Space: O(n)

Spotting the pattern

This is a Tree Traversal problem. The key question to ask yourself:

Can I recursively compare corresponding nodes in both trees and short-circuit on any mismatch?

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.

Premium

Unlock the full guided solution

The Tree Traversal walkthrough for Same 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
B
Big_Wolverine_7575Founding Member· unprompted on Reddit

“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 · both courses

Full access

$49.99 / year

or $9.99 / 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.