组会挨说，天气阴沉，晚上又吃了山城辣妹子火锅并焦急等待offer的小黑黑的leetcode之旅:1110. 删点成林

最新推荐文章于 2024-07-15 12:10:21 发布

爱喝喜茶爱吃烤冷面的小黑黑

最新推荐文章于 2024-07-15 12:10:21 发布

阅读量487

点赞数

分类专栏：小黑的日常leetcode之旅文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/qq_37418807/article/details/127207308

版权

小黑的日常leetcode之旅专栏收录该内容

225 篇文章 1 订阅

订阅专栏

小黑做法

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def delNodes(self, root: TreeNode, to_delete: List[int]) -> List[TreeNode]:
        # root为空的情况
        if not root:
            return root
        # 初始化
        self.node_list = [root]
        # 递归删除函数
        def delete_node(node,val):
            # 遍历左子树
            if node.left:
                if node.left.val == val:
                    if node.left.left:
                        self.node_list.append(node.left.left)
                    if node.left.right:
                        self.node_list.append(node.left.right)
                    node.left = None
                    return
                delete_node(node.left,val)
            # 遍历右子树
            if node.right:
                if node.right.val == val:
                    if node.right.left:
                        self.node_list.append(node.right.left)
                    if node.right.right:
                        self.node_list.append(node.right.right)
                    node.right = None
                    return
                delete_node(node.right,val)
        # 依次遍历要删除的数字
        for val in to_delete:
            i = 0
            while i < len(self.node_list):
                node = self.node_list[i]
                # 判断根节点是否是val
                if node.val == val:
                    if node.left:
                        self.node_list.append(node.left)
                    if node.right:
                        self.node_list.append(node.right)
                    self.node_list.pop(i)
                else:    
                    delete_node(node,val)
                    i += 1
                
        return self.node_list

在这里插入图片描述

后序遍历法1(python)

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def delNodes(self, root: TreeNode, to_delete: List[int]) -> List[TreeNode]:
        # root为空,跳出
        if not root:
            return []
        # 初始化变量
        self.to_delete = to_delete
        self.ans = []
        # 定义递归函数,返回该结点是否应该被删除，并调整子树
        def helper(node,existParent):
            # 结点为空时
            if not node:
                return False
            # 定义该结点是否应该被删除
            is_delete = node.val in self.to_delete
            # 递归左右子树
            left_delete = helper(node.left,not is_delete)
            right_delete = helper(node.right,not is_delete)
            if left_delete:
                node.left = None
            if right_delete:
                node.right = None
            if not existParent and not is_delete:
                self.ans.append(node)
            return is_delete
        helper(root,False)
        return self.ans

在这里插入图片描述

后序遍历法1(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 {
    // set初始化
    Set<Integer> to_delete;
    List<TreeNode> ans;
    public List<TreeNode> delNodes(TreeNode root, int[] to_delete) {
        //初始化变量
        this.to_delete = Arrays.stream(to_delete).boxed().collect(Collectors.toSet());
        this.ans = new ArrayList<>();
        helper(root,false);
        return this.ans;
    }
    public boolean helper(TreeNode node,boolean existParent){
        // 递归出口
        if(node == null){
            return false;
        }
        // 该结点是否应该被删除
        boolean is_delete = this.to_delete.contains(node.val);
        // 左右结点是否应该被删除
        boolean left_delete = helper(node.left,!is_delete);
        boolean right_delete = helper(node.right,!is_delete);
        if(left_delete){
            node.left = null;
        }
        if(right_delete){
            node.right = null;
        }
        if(!is_delete && !existParent){
            this.ans.add(node);
        }
        return is_delete;
    }
}

在这里插入图片描述

后跟遍历法2(python)

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def delNodes(self, root: TreeNode, to_delete: List[int]) -> List[TreeNode]:
        # root为空
        if not root:
            return []
        self.to_delete = to_delete
        self.ans = [root] if root.val not in to_delete else []
        # 递归函数
        def helper(node,parent,des):
            if not node:
                return
            helper(node.left,node,'left')
            helper(node.right,node,'right')

            if node.val in self.to_delete:
                # 插下
                if node.left:
                    self.ans.append(node.left)
                if node.right:
                    self.ans.append(node.right)
                # 剪掉本结点
                if des == 'left':
                    parent.left = None
                if des == 'right':
                    parent.right = None
        helper(root,None,None)
        return self.ans

在这里插入图片描述

后跟遍历法2(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 {
    Set<Integer> to_delete;
    List<TreeNode> ans;
    public List<TreeNode> delNodes(TreeNode root, int[] to_delete) {
        if(root == null){
            return null;
        }
        this.to_delete = Arrays.stream(to_delete).boxed().collect(Collectors.toSet());
        this.ans = new ArrayList<>();
        if(!this.to_delete.contains(root.val)){
            this.ans.add(root);
        }
        helper(root,null,null);
        return this.ans;
    }
    public void helper(TreeNode node,TreeNode parent,String des){
        if(node == null){
            return;
        }
        // 遍历左右子树
        helper(node.left,node,"left");
        helper(node.right,node,"right");
        if(this.to_delete.contains(node.val)){
            // 插入孩子结点
            if(node.left != null){
                this.ans.add(node.left);
            }
            if(node.right != null){
                this.ans.add(node.right);
            }
            // 删除该结点
            if(des == "left"){
                parent.left = null;
            }
            if(des == "right"){
                parent.right = null;
            }
        }
    }
}