1110. 删点成林

给出二叉树的根节点 root，树上每个节点都有一个不同的值。

如果节点值在 to_delete 中出现，我们就把该节点从树上删去，最后得到一个森林（一些不相交的树构成的集合）。

返回森林中的每棵树。你可以按任意顺序组织答案。

示例 1：

输入：root = [1,2,3,4,5,6,7], to_delete = [3,5]
输出：[[1,2,null,4],[6],[7]]
示例 2：

输入：root = [1,2,4,null,3], to_delete = [3]
输出：[[1,2,4]]
 

提示：

树中的节点数最大为 1000。
每个节点都有一个介于 1 到 1000 之间的值，且各不相同。
to_delete.length <= 1000
to_delete 包含一些从 1 到 1000、各不相同的值。

写在前面：致力于写出最好理解的题解。

解题思路
对于被删除节点类型，可以分情况进行分析：

叶子节点：直接删掉
非叶子节点：如果左右子树不为空，就加入结果集。
为了得到这个结果集，每个结点需要做什么？

每个结点要知道自己是否需要被删掉，如果需要被删掉，那么就根据情况执行上一步的分析。
在什么时候做这些事？

如果一个结点需要被删掉，那么应该将它与父节点的关系进行移除，所以我们需要：判断完结点是否需要被删除后，告知他的父节点进行相应的指针操作。

那么不妨采用后序遍历的方式。

定义一个删除函数

/**
* 定义：
* 删除以node为根的树中，结点值出现在delete中的结点,更新结果集list，并返回删除后新的根节点。
*/
TreeNode del(TreeNode node, Set<Integer> delete, List<TreeNode> list);
把上述思考过程直接翻译成代码：

    TreeNode del(TreeNode node, Set<Integer> delete, List<TreeNode> list){
        if(node == null) return null; // base case
        // 先递归左右子树
        node.left = del(node.left, delete, list);
        node.right = del(node.right, delete,list);
        
        if(delete.contains(node.val)){ // 当node结点需要被删掉时,更新结果集
            if(node.left != null){ 
                list.add(node.left);
            }
            if(node.right != null){ 
                list.add(node.right);
            }
            // 如果结果集里已经包含node为根的树，就把结果集里的node删掉
            if(list.contains(node)){
                list.remove(node);
            }
            // 将node置为null，等于删除掉了
            return null;
        }
        return node;
    }
那么在执行del()方法前，我们需要做什么准备工作呢？

构建一个 delete 集合
将最初的根节点加入结果集，这么做的原因是：如果没有要删除的结点，那么del方法是不会将根节点加入结果集的，所以我们需要提前加入，并且在del方法中会维护指针索引，所以结果集中的树结构会保证正确。

    public List<TreeNode> delNodes(TreeNode root, int[] to_delete) {
        List<TreeNode> list = new LinkedList<>();
        Set<Integer> set = new HashSet<>();
        // 将delete转换为set方便进行判断
        for(int num : to_delete){
            set.add(num);
        }
        // 如果什么都不需要删掉，那么结果集中应该包含原本这棵树
        list.add(root);
        del(root, set, list);
        return list;
    }

    TreeNode del(TreeNode node, Set<Integer> delete, List<TreeNode> list){
        if(node == null) return null;
        node.left = del(node.left, delete, list);
        node.right = del(node.right, delete,list);
        if(delete.contains(node.val)){
            if(node.left != null){
                list.add(node.left);
            }
            if(node.right != null){
                list.add(node.right);
            }
            if(list.contains(node)){
                list.remove(node);
            }
            return null;
        }
        return node;
    }

解题思路

findNodes函数解决了连环删除的情况，就是父子节点都要被删除

class Solution {

    Set<Integer> to_delete_set;
    List<TreeNode> res; 

    public List<TreeNode> delNodes(TreeNode root, int[] to_delete) {

        to_delete_set = new HashSet<>();
        for(int i : to_delete){
            to_delete_set.add(i);
        }

        res = new LinkedList<>();

        findNodes(root);

        return res;
    }

    public void findNodes(TreeNode root){// 如果当前节点是删除的，那跳过（由于母节点在调用时要么为空要么也为被删除，因此不需要断开树），如果不删除，那么首先加入res，然后BFS寻找需要删除的

        if(root == null){
            return;
        }

        if(to_delete_set.contains(root.val)){// 解决了连环删除的情况
            findNodes(root.left);
            findNodes(root.right);
            return;
        }

        res.add(root);

        List<TreeNode> layer = new LinkedList<>();
        layer.add(root);

        while(!layer.isEmpty()){
            List<TreeNode> nextLayer = new LinkedList<>();
            for(TreeNode node : layer){
                
                if(node == null){
                    continue;
                }

                if(node.left != null){// 因为要断开树，因此验证的是子节点
                    if(to_delete_set.contains(node.left.val)){
                        findNodes(node.left.left);
                        findNodes(node.left.right);
                        node.left = null;
                    }else{
                        nextLayer.add(node.left);
                    }
                }

                if(node.right != null){
                    if(to_delete_set.contains(node.right.val)){
                        findNodes(node.right.left);
                        findNodes(node.right.right);
                        node.right = null;
                    }else{
                        nextLayer.add(node.right);
                    }
                }
            }
            layer = nextLayer;
        }
    }
}