Find Duplicate Subtrees - Practice Coding Problems

Find Duplicate Subtrees - Problem

Imagine you're a botanist studying the genetic patterns in a family tree of plants. You've discovered that some branches of the tree have evolved into identical genetic structures - essentially becoming duplicates of each other!

Given the root of a binary tree, your task is to find all duplicate subtrees and return a list containing one representative root node from each group of duplicates. Two subtrees are considered duplicates if they have exactly the same structure with identical node values at corresponding positions.

For example, if you find 3 identical subtrees in the tree, you only need to return the root of one of them. The goal is to identify all the different "genetic patterns" that appear multiple times in your tree.

Input: Root of a binary tree
Output: List of root nodes representing each type of duplicate subtree

Input & Output

example_1.py — Basic Tree with Duplicates

$ Input: [1,2,3,4,null,2,4,null,null,4]

› Output: [2,4]

💡 Note: Tree has subtrees rooted at nodes with values 2 and 4 that appear multiple times. The subtree '4(null)(null)' appears 3 times, and subtree '2(4(null)(null))(null)' appears 2 times.

example_2.py — Simple Duplicate

$ Input: [2,1,1]

› Output: [1]

💡 Note: The subtree consisting of just node 1 appears twice (as left and right children of root). We return one representative.

example_3.py — No Duplicates

$ Input: [2,2,2,3,null,3,null]

› Output: []

💡 Note: Although nodes have same values, the subtree structures are different. No duplicate subtrees exist, so return empty list.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-200 ≤ Node.val ≤ 200

Visualization

Tap to expand

Understanding the Visualization

Start DFS Traversal

Begin post-order traversal from root, processing children before parents

Serialize Each Subtree

Create unique string fingerprint: 'value(left_pattern)(right_pattern)'

Hash Table Lookup

Check if this genetic pattern has been seen before in our catalog

Count & Detect

Increment pattern count. When count reaches 2, we found a duplicate family!

Key Takeaway

🎯 Key Insight: Convert each subtree into a unique string fingerprint during post-order traversal. Use hash map to track pattern frequencies - when a pattern appears twice, you've found a duplicate!

Asked in

G Google 67 a Amazon 45 ⊞ Microsoft 38 f Meta 29

The optimal approach uses post-order DFS traversal with subtree serialization. Each subtree is converted to a unique string representation, and a hash map tracks occurrence counts. When a serialization appears for the second time, we've found a duplicate subtree. This achieves O(n) time complexity with a single pass through the tree.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Serialization (Optimal)	O(n)	O(n)	Serialize subtrees during DFS traversal and detect duplicates immediately
Brute Force (Compare All Subtrees)	O(n³)	O(n²)	Compare every subtree with every other subtree directly

One-Pass Serialization (Optimal) — Algorithm Steps

Perform post-order DFS traversal of the tree
For each node, serialize its subtree as 'val(left_serial)(right_serial)'
Use hash map to count occurrences of each serialization
When count reaches exactly 2, add the node to results
Return collected duplicate subtree roots

Visualization

Tap to expand

Step-by-Step Walkthrough

Post-order Traversal

Visit children before processing current node

Serialize Subtree

Create unique string representation: 'val(left)(right)'

Hash Table Lookup

Check if this pattern has been seen before

Duplicate Detection

When count reaches 2, we found a duplicate pattern

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

#define MAX_NODES 1000
#define MAX_STR_LEN 10000

struct HashEntry {
    char key[MAX_STR_LEN];
    int count;
};

static struct HashEntry hash_table[MAX_NODES];
static int hash_size = 0;
static struct TreeNode** result;
static int result_size = 0;

int hash_lookup(const char* key) {
    for (int i = 0; i < hash_size; i++) {
        if (strcmp(hash_table[i].key, key) == 0) {
            return i;
        }
    }
    return -1;
}

void hash_insert(const char* key) {
    int idx = hash_lookup(key);
    if (idx == -1) {
        strcpy(hash_table[hash_size].key, key);
        hash_table[hash_size].count = 1;
        hash_size++;
    } else {
        hash_table[idx].count++;
    }
}

int hash_get_count(const char* key) {
    int idx = hash_lookup(key);
    return idx == -1 ? 0 : hash_table[idx].count;
}

char* serialize(struct TreeNode* node, char* buffer) {
    if (!node) {
        strcpy(buffer, "null");
        return buffer;
    }
    
    char left_buffer[MAX_STR_LEN], right_buffer[MAX_STR_LEN];
    serialize(node->left, left_buffer);
    serialize(node->right, right_buffer);
    
    sprintf(buffer, "%d(%s)(%s)", node->val, left_buffer, right_buffer);
    
    hash_insert(buffer);
    
    if (hash_get_count(buffer) == 2) {
        result[result_size++] = node;
    }
    
    return buffer;
}

struct TreeNode** findDuplicateSubtrees(struct TreeNode* root, int* returnSize) {
    hash_size = 0;
    result_size = 0;
    result = malloc(MAX_NODES * sizeof(struct TreeNode*));
    
    char buffer[MAX_STR_LEN];
    serialize(root, buffer);
    
    *returnSize = result_size;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS traversal where each node is visited once

✓ Linear Growth

Space Complexity

O(n)

Hash map storage for serializations plus recursion stack

⚡ Linearithmic Space

89.2K Views

Medium Frequency

~25 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Serialization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler