[LeetCode] 1660. Correct a Binary Tree

You have a binary tree with a small defect. There is exactly one invalid node where its right child incorrectly points to another node at the same depth but to the invalid node's right.

Given the root of the binary tree with this defect, root, return the root of the binary tree after removing this invalid node and every node underneath it (minus the node it incorrectly points to).

Custom testing:

The test input is read as 3 lines:

• TreeNode root
• int fromNode (not available to correctBinaryTree)
• int toNode (not available to correctBinaryTree)

After the binary tree rooted at root is parsed, the TreeNode with value of fromNode will have its right child pointer pointing to the TreeNode with a value of toNode. Then, root is passed to correctBinaryTree.

Example 1:

Input: root = [1,2,3], fromNode = 2, toNode = 3
Output: [1,null,3]
Explanation: The node with value 2 is invalid, so remove it.

Example 2:

Input: root = [8,3,1,7,null,9,4,2,null,null,null,5,6], fromNode = 7, toNode = 4
Output: [8,3,1,null,null,9,4,null,null,5,6]
Explanation: The node with value 7 is invalid, so remove it and the node underneath it, node 2.

Constraints:

• The number of nodes in the tree is in the range [3, 104].
• -109 <= Node.val <= 109
• All Node.val are unique.
• fromNode != toNode
• fromNode and toNode will exist in the tree and will be on the same depth.
• toNode is to the right of fromNode.
• fromNode.right is null in the initial tree from the test data.

纠正二叉树。

你有一棵二叉树，这棵二叉树有个小问题，其中有且只有一个无效节点，它的右子节点错误地指向了与其在同一层且在其右侧的一个其他节点。

给定一棵这样的问题二叉树的根节点 root ，将该无效节点及其所有子节点移除（除被错误指向的节点外），然后返回新二叉树的根结点。

自定义测试用例：

测试用例的输入由三行组成：

TreeNode root
int fromNode （在 correctBinaryTree 中不可见）
int toNode （在 correctBinaryTree 中不可见）
当以 root 为根的二叉树被解析后，值为 fromNode 的节点 TreeNode 将其右子节点指向值为 toNode 的节点 TreeNode 。然后， root 传入 correctBinaryTree 的参数中。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/correct-a-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路是BFS层序遍历。因为有错误的是某个node的右指针，所以我们的层序遍历会有一点变化，对于每一层的节点，我们从右往左遍历，遍历的时候我们把当前节点的左右孩子放入hashset，在遍历的时候，同时试探hashset里面是否已经存在左/右孩子的右孩子了，如果存在，说明左/右孩子的右指针指向了当前层的某个节点。我们去掉这个指向有错误的孩子即可。

时间O(n)

空间O(n)

Java实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode correctBinaryTree(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList();
        HashSet<TreeNode> set = new HashSet<>();
        queue.offer(root);
        int size = 1;
        while (size > 0) {
            TreeNode cur = queue.poll();
            size--;
            if (cur.right != null) {
                set.add(cur.right);
                queue.offer(cur.right);
                // cur.right.right本应该再下一层，如果出现在当前层则说明这个节点的right指针连错了
                if (set.contains(cur.right.right)) {
                    cur.right = null;
                    break;
                }
            }
            if (cur.left != null) {
                set.add(cur.left);
                queue.offer(cur.left);
                // cur.left.right本应该再下一层，如果出现在当前层则说明这个节点的right指针连错了
                if (set.contains(cur.left.right)) {
                    cur.left = null;
                    break;
                }
            }
            if (size == 0) {
                size = queue.size();
                set = new HashSet<>();
            }
        }
        return root;
    }
}

LeetCode 题目总结