1110. Delete Nodes And Return Forest

最新推荐文章于 2024-03-20 17:26:06 发布

m1f2c3

最新推荐文章于 2024-03-20 17:26:06 发布

阅读量222

点赞数

分类专栏： LeetCode 文章标签： a

本文链接：https://blog.csdn.net/m1f2c3/article/details/94991719

版权

LeetCode 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<TreeNode> delNodes(TreeNode root, int[] to_delete) {
        TreeNode Fa = new TreeNode(0);
        Fa.left = root;
        List<TreeNode> res = new ArrayList<>();
        List<Integer> to_del = new ArrayList<>();
        for(int i = 0; i < to_delete.length; ++i){
            to_del.add(to_delete[i]);
        }

        delCore(Fa, to_del, res);
        boolean add_flag = true;
        for(int i = 0; i < to_delete.length; ++i){
            if(to_delete[i] == root.val){
                add_flag = false;
                break;
            }
        }
        if(add_flag == true){
            res.add(root);
        }
        return res;
    }
    
    public void delCore(TreeNode root, List<Integer> to_del, List<TreeNode> trees){
        if(root.left != null){
            delCore(root.left, to_del, trees);
            for(int i = 0; i < to_del.size(); ++i){
                if(to_del.get(i) == root.left.val){
                    to_del.remove(i);
                    if(root.left.left != null){
                        trees.add(root.left.left);
                    }
                    if(root.left.right != null){
                        trees.add(root.left.right);
                    }
                    root.left = null;
                    break;
                }
            }

        }

        if(root.right != null){
            delCore(root.right, to_del, trees);
            for (int i = 0; i < to_del.size(); ++i){
                if(to_del.get(i) == root.right.val){
                    to_del.remove(i);
                    if(root.right.left != null){
                        trees.add(root.right.left);
                    }
                    if(root.right.right != null){
                        trees.add(root.right.right);
                    }
                    root.right = null;
                    break;
                }
            }
        }
    }
}

这道题可以用前序遍历和后续遍历解出，更加清晰易懂

这是前序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<TreeNode> delNodes(TreeNode root, int[] to_delete) {
        List<TreeNode> res = new ArrayList<>();
        delNodesCore(root, to_delete, true, res);
        return res;
    }
    
    public static TreeNode delNodesCore(TreeNode root, int[] to_delete, boolean flag, List<TreeNode> tn) {
        TreeNode res = root;
        boolean temp_flag = false;

        for(int mem : to_delete){
            if(mem == root.val){
                res = null;
                break;
            }
        }

        if(res == null){
            temp_flag = true;
        }else{
            temp_flag = false;
            if(flag == true){
                tn.add(root);
            }
        }

        if(root.left != null){
            root.left = delNodesCore(root.left, to_delete, temp_flag, tn);
        }
        if(root.right != null){
            root.right = delNodesCore(root.right, to_delete, temp_flag, tn);
        }
        return res;
    }
}

在这里插入图片描述

后续遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<TreeNode> delNodes(TreeNode root, int[] to_delete) {
        List<TreeNode> res = new ArrayList<>();
        TreeNode cb = delNodesCore(root, to_delete, res);
        if(cb != null){
            res.add(root);
        }
        return res;
    }
    
    public static TreeNode delNodesCore(TreeNode root, int[] to_delete, List<TreeNode> tn) {
        TreeNode res = root;

        if(root.left != null){
            root.left = delNodesCore(root.left, to_delete, tn);
        }
        if(root.right != null){
            root.right = delNodesCore(root.right, to_delete, tn);
        }
        for(int mem : to_delete){
            if(mem == root.val){
                if(root.left != null){
                    tn.add(root.left);
                }
                if(root.right != null){
                    tn.add(root.right);
                }
                res = null;
                break;
            }
        }
        return res;
    }
}