Find Elements in a Contaminated Binary Tree

Find Elements in a Contaminated Binary Tree - Problem

Binary Tree Recovery Challenge

Imagine you have a perfectly structured binary tree with a beautiful mathematical pattern, but it has been contaminated - all values have been changed to -1! Your mission is to recover the original tree and implement an efficient search mechanism.

The original tree follows these recovery rules:
• Root starts at 0
• Left child of node with value x gets 2*x + 1
• Right child of node with value x gets 2*x + 2

You need to implement a FindElements class that:
1. Recovers the contaminated binary tree in the constructor
2. Searches for target values efficiently with the find(target) method

Example tree structure:

       0
     /   \
    1     2
   / \   / \
  3   4 5   6

Input & Output

example_1.py — Basic Tree Recovery

$ Input: Tree: [null,null,null] (contaminated), Operations: ["FindElements","find","find"] Arguments: [[root],[1],[2]]

› Output: [null,false,false]

💡 Note: Single root node gets value 0, so find(1) and find(2) both return false since only 0 exists in the recovered tree.

example_2.py — Complete Binary Tree

$ Input: Tree: [-1,-1,-1,-1,-1] (contaminated), Operations: ["FindElements","find","find","find","find"] Arguments: [[root],[1],[3],[5],[2]]

› Output: [null,true,true,false,true]

💡 Note: Recovered tree has values [0,1,2,3,4]. find(1)=true, find(3)=true, find(5)=false (doesn't exist), find(2)=true.

example_3.py — Edge Case Single Node

$ Input: Tree: [-1] (contaminated), Operations: ["FindElements","find","find"] Arguments: [[root],[0],[1]]

› Output: [null,true,false]

💡 Note: Single node tree recovers to just [0]. find(0)=true (root exists), find(1)=false (no children).

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
At most 10⁴ calls will be made to find
All original tree values are distinct and in the range [0, 10⁶]
Tree structure follows the mathematical pattern exactly

Visualization

Tap to expand

Understanding the Visualization

Start Recovery

Begin at contaminated root (-1), assign correct value (0), add to search index

Process Children

For each node, calculate children values using 2*x+1 and 2*x+2 formula

Build Index

As we recover each node, immediately add its value to our hash set

Fast Search

All search queries become instant hash lookups in our pre-built index

Key Takeaway

🎯 Key Insight: Since we must traverse every node to recover the tree anyway, building our search index during the same traversal gives us O(1) queries with no extra tree traversals!

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses a one-pass hash set approach during tree recovery. While traversing the contaminated tree to restore values using the mathematical pattern (root=0, left=2*parent+1, right=2*parent+2), we simultaneously build a hash set of all recovered values. This enables O(1) search queries after O(n) preprocessing, making it perfect for multiple find operations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Tree Traversal for Each Search)	O(n) per query	O(h)	Recover tree once, then traverse entire tree for each search query
One-Pass Hash Set (Optimal)	O(1) per query	O(n)	Build hash set of recovered values during single tree traversal

Brute Force (Tree Traversal for Each Search) — Algorithm Steps

In constructor: traverse tree and restore all values using the mathematical pattern
For each find() call: perform DFS/BFS traversal to search for target
Return true if target found during traversal, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Recover Tree

First pass: restore all node values using mathematical pattern

Search Query

For each find() call, traverse entire tree looking for target

Repeat

Every query requires O(n) traversal regardless of previous searches

Code -

solution.c — C

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

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

typedef struct {
    struct TreeNode* root;
} FindElements;

void recoverTree(struct TreeNode* node, int val) {
    if (!node) return;
    node->val = val;
    recoverTree(node->left, 2 * val + 1);
    recoverTree(node->right, 2 * val + 2);
}

bool dfsSearch(struct TreeNode* node, int target) {
    if (!node) return false;
    if (node->val == target) return true;
    return dfsSearch(node->left, target) || dfsSearch(node->right, target);
}

FindElements* findElementsCreate(struct TreeNode* root) {
    FindElements* obj = (FindElements*)malloc(sizeof(FindElements));
    obj->root = root;
    recoverTree(root, 0);
    return obj;
}

bool findElementsFind(FindElements* obj, int target) {
    return dfsSearch(obj->root, target);
}

void findElementsFree(FindElements* obj) {
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n) per query

Each find() operation requires traversing potentially all n nodes in worst case

✓ Linear Growth

Space Complexity

O(h)

Only recursion stack space proportional to tree height h

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Brute Force (Tree Traversal for Each Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler