Correct a Binary Tree - Practice Coding Problems

Correct a Binary Tree - Problem

Correct a Binary Tree

You're given a binary tree that has been corrupted! 🔧 There's exactly one defective node where its right child incorrectly points to another node at the same depth, but further to the right (instead of pointing to its actual right child or null).

Your mission is to detect and remove this corrupted node along with its entire subtree, then return the corrected binary tree.

Key Points:
• The invalid node's right pointer goes to a node at the same level
• The target node is to the right of the invalid node
• Remove the invalid node and everything below it
• Keep the incorrectly pointed-to node (it's innocent!)

Example: If node 2's right child incorrectly points to node 5 (instead of node 3), remove node 2 and its subtree, but keep node 5 in its correct position.

Input & Output

example_1.py — Basic Invalid Node

$ Input: root = [1,2,3,4,null,null,null], fromNode = 2, toNode = 3

› Output: [1,null,3]

💡 Note: Node 2's right child incorrectly points to node 3 (which should be at the same level). After removing node 2 and its subtree (including node 4), we get the corrected tree with root 1 having only a right child 3.

example_2.py — Deeper Tree

$ Input: root = [1,2,3,4,5,6,7], fromNode = 4, toNode = 5

› Output: [1,null,3,null,null,6,7]

💡 Note: Node 4 incorrectly points to node 5. After removing node 4 (and any children it might have had), node 2 becomes a leaf, and the tree structure is preserved correctly.

example_3.py — Root is Invalid

$ Input: root = [1,2], fromNode = 1, toNode = 2

› Output: null

💡 Note: The root node itself is invalid (pointing to its own child incorrectly). Since we remove the invalid node, the entire tree is removed, resulting in null.

Constraints

The number of nodes in the tree is in the range [2, 10⁴]
1 ≤ Node.val ≤ 10⁴
There is exactly one invalid node
The invalid node's right child points to another node at the same depth
The pointed-to node is to the right of the invalid node

Visualization

Tap to expand

Understanding the Visualization

Survey the Scene

Use level-order traversal to examine each generation of the family tree

Right-to-Left Investigation

In each generation, investigate from right to left, keeping track of who you've seen

Spot the Fraud

If someone points to a person you've already interviewed, that's the fraud!

Remove the Criminal

Remove the fraudulent person and their entire lineage from the family tree

Case Closed

Return the cleaned up, legitimate family tree

Key Takeaway

🎯 Key Insight: Since invalid nodes always point RIGHT, processing levels from right-to-left lets us catch 'future references' immediately - like a detective who interviews the rightmost family members first and catches anyone pointing to someone they've already met!

Asked in

f Meta 25 G Google 20 a Amazon 15 ⊞ Microsoft 10

The optimal approach uses right-to-left BFS traversal with a hash set. Since invalid nodes point to nodes on their RIGHT at the same level, processing each level from right-to-left allows us to detect invalid forward references immediately when we encounter a node whose right child is already in our 'seen' set. This achieves O(n) time complexity with O(w) space where w is the maximum width of the tree.

Common Approaches

Approach	Time	Space	Notes
✓ Right-to-Left BFS with Set (Optimal)	O(n)	O(w)	Traverse right-to-left, track seen nodes, detect future references
Brute Force (Level-Order Validation)	O(n²)	O(n)	Check every node against every other node at the same level

Right-to-Left BFS with Set (Optimal) — Algorithm Steps

Use BFS to traverse tree level by level
For each level, process nodes from RIGHT to LEFT
Maintain a set of nodes seen so far in current level
If any node's right child exists in the seen set, it's invalid
Remove the invalid node and return corrected tree

Visualization

Tap to expand

Step-by-Step Walkthrough

BFS Level Traversal

Use BFS to process tree level by level

Right-to-Left Processing

Process each level from rightmost to leftmost node

Track Seen Nodes

Maintain set of nodes seen so far in current level

Detect Invalid Reference

If node's right child is in seen set, it's invalid

Remove and Return

Remove invalid node and return corrected tree

Code -

solution.c — C

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

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

struct Queue {
    struct TreeNode **data;
    int front, rear, size, capacity;
};

struct Queue* createQueue(int capacity) {
    struct Queue* queue = malloc(sizeof(struct Queue));
    queue->data = malloc(capacity * sizeof(struct TreeNode*));
    queue->front = 0;
    queue->rear = -1;
    queue->size = 0;
    queue->capacity = capacity;
    return queue;
}

void enqueue(struct Queue* queue, struct TreeNode* node) {
    if (queue->size < queue->capacity) {
        queue->rear = (queue->rear + 1) % queue->capacity;
        queue->data[queue->rear] = node;
        queue->size++;
    }
}

struct TreeNode* dequeue(struct Queue* queue) {
    if (queue->size > 0) {
        struct TreeNode* node = queue->data[queue->front];
        queue->front = (queue->front + 1) % queue->capacity;
        queue->size--;
        return node;
    }
    return NULL;
}

bool inSeen(struct TreeNode** seen, int seenSize, struct TreeNode* target) {
    for (int i = 0; i < seenSize; i++) {
        if (seen[i] == target) return true;
    }
    return false;
}

struct TreeNode* removeInvalidNode(struct TreeNode* root, struct TreeNode* invalidNode) {
    if (!root) return NULL;
    if (root == invalidNode) return NULL;
    
    if (root->left == invalidNode) {
        root->left = NULL;
    } else if (root->right == invalidNode) {
        root->right = NULL;
    } else {
        root->left = removeInvalidNode(root->left, invalidNode);
        root->right = removeInvalidNode(root->right, invalidNode);
    }
    
    return root;
}

struct TreeNode* correctBinaryTree(struct TreeNode* root) {
    if (!root) return NULL;
    
    struct Queue* queue = createQueue(10000);
    enqueue(queue, root);
    
    while (queue->size > 0) {
        int levelSize = queue->size;
        struct TreeNode** levelNodes = malloc(levelSize * sizeof(struct TreeNode*));
        struct TreeNode** seen = malloc(levelSize * sizeof(struct TreeNode*));
        int seenSize = 0;
        
        // Collect level nodes
        for (int i = 0; i < levelSize; i++) {
            levelNodes[i] = dequeue(queue);
        }
        
        // Process from right to left
        for (int i = levelSize - 1; i >= 0; i--) {
            struct TreeNode* node = levelNodes[i];
            
            // If right child points to already seen node, invalid
            if (node->right && inSeen(seen, seenSize, node->right)) {
                struct TreeNode* result = removeInvalidNode(root, node);
                free(levelNodes);
                free(seen);
                free(queue->data);
                free(queue);
                return result;
            }
            
            seen[seenSize++] = node;
            
            // Add children for next level
            if (node->left) enqueue(queue, node->left);
            if (node->right) enqueue(queue, node->right);
        }
        
        free(levelNodes);
        free(seen);
    }
    
    free(queue->data);
    free(queue);
    return root;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during BFS traversal

✓ Linear Growth

Space Complexity

O(w)

Where w is maximum width of tree (for queue and seen set)

✓ Linear Space

23.5K 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

Right-to-Left BFS with Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler