# Delete Nodes And Return Forest

Given the `root` of a binary tree, each node in the tree has a distinct value. After deleting all nodes with a value in `to_delete`, we are left with a forest (a disjoint union of trees). Return the roots of the trees in the remaining forest. You may return the result in any order.

Example:

```Input: root = [1,2,3,4,5,6,7], to_delete = [3,5]
Output: [[1,2,null,4],[6],[7]]
```

Constraints:

• The number of nodes in the given tree is at most `1000`.
• Each node has a distinct value between `1` and `1000`.
• `to_delete.length <= 1000`
• `to_delete` contains distinct values between `1` and `1000`.
```/**
* 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 List<TreeNode> delNodes(TreeNode root, int[] to_delete) {
List<TreeNode> forrest = new ArrayList<>();
if (root == null) {
return forrest;
}
Set<Integer> toDelete = new HashSet<>();
for (int num : to_delete) {
}
root = deleteNodeAndCreateForrest(root, toDelete, forrest);
if (root != null) {
}
return forrest;
}

private TreeNode deleteNodeAndCreateForrest(TreeNode node, Set<Integer> toDelete,
List<TreeNode> forrest) {
if (node == null) {
return null;
}
node.left = deleteNodeAndCreateForrest(node.left, toDelete, forrest);
node.right = deleteNodeAndCreateForrest(node.right, toDelete, forrest);
if (toDelete.contains(node.val)) {
if (node.left != null && !toDelete.contains(node.left.val)) {
}
if (node.right != null && !toDelete.contains(node.right.val)) {