Find Elements in a Contaminated Binary Tree

Find Elements in a Contaminated Binary Tree - Problem

You are given a binary tree with the following rules:

root.val == 0
If treeNode.val == x and treeNode.left != null, then treeNode.left.val == 2 * x + 1
If treeNode.val == x and treeNode.right != null, then treeNode.right.val == 2 * x + 2

Now the binary tree is contaminated, which means all treeNode.val have been changed to -1.

Implement the FindElements class:

FindElements(TreeNode root) Initializes the object with a contaminated binary tree and recovers it.
bool find(int target) Returns true if the target value exists in the recovered binary tree.

Input & Output

Example 1 — Basic Tree Recovery

$ Input: root = [-1,-1,-1,-1,-1], operations = [["find",1],["find",3],["find",5]]

› Output: [true,true,false]

💡 Note: Tree structure: root=0, left=1, right=2, left.left=3, left.right=4. Values 1 and 3 exist, but 5 does not.

Example 2 — Single Node Tree

$ Input: root = [-1], operations = [["find",0],["find",1]]

› Output: [true,false]

💡 Note: Only root exists with value 0. Value 1 would be left child but doesn't exist.

Example 3 — Larger Tree

$ Input: root = [-1,-1,-1,-1,-1,-1,-1], operations = [["find",2],["find",6],["find",7]]

› Output: [true,true,false]

💡 Note: Complete binary tree: 0→1,2→3,4,5,6. Values 2 and 6 exist, but 7 would be at position not in tree.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
At most 10⁴ calls will be made to find

Visualization

Tap to expand

Asked in

F Facebook 15 G Google 12 A Amazon 8

The key insight is to use the parent-child relationship (left = 2*x+1, right = 2*x+2) to recover original values. Best approach uses hash set preprocessing for O(1) queries after O(n) initialization. Time: O(n + q), Space: O(n)

Common Approaches

✓ Brute Force - Search Every Time

⏱️ Time: O(n * q) Space: O(h)

For each find query, traverse the entire tree using DFS, calculating the correct values based on the parent-child relationship formula (2*x+1 for left, 2*x+2 for right).

Hash Set Preprocessing

⏱️ Time: O(n + q) Space: O(n)

During initialization, traverse the tree once to recover all values using DFS and store them in a hash set. Each find operation becomes O(1) lookup in the hash set.

Brute Force - Search Every Time — Algorithm Steps

Step 1: For each find operation, start DFS from root
Step 2: Calculate node values using 2*x+1 (left) and 2*x+2 (right)
Step 3: Return true if target found during traversal

Visualization

Tap to expand

Step-by-Step Walkthrough

Query

Receive find(target) request

DFS

Traverse tree calculating values using 2*x+1, 2*x+2

Result

Return true if target found, false otherwise

Code -

solution.c — C

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

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

typedef struct {
    struct TreeNode* root;
} FindElements;

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

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

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

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int main() {
    // For demonstration, creating a simple test case
    struct TreeNode* root = createNode(-1);
    root->left = createNode(-1);
    root->right = createNode(-1);
    root->left->left = createNode(-1);
    root->left->right = createNode(-1);
    
    FindElements* fe = findElementsCreate(root);
    
    printf("[%s,%s,%s]\n", 
           findElementsFind(fe, 1) ? "true" : "false",
           findElementsFind(fe, 3) ? "true" : "false",
           findElementsFind(fe, 5) ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * q)

For q queries, each traverses up to n nodes in the tree

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

428 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 - Search Every Time — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler