LeetCode - Medium - 1325. Delete Leaves With a Given Value

最新推荐文章于 2024-10-01 05:07:35 发布

巨輪

最新推荐文章于 2024-10-01 05:07:35 发布

阅读量238

点赞数

分类专栏： LeetCode 文章标签： leetcode tree dfs

本文链接：https://blog.csdn.net/u011863024/article/details/118488575

版权

LeetCode 专栏收录该内容

210 篇文章 14 订阅

订阅专栏

给定一个二叉树和一个整数目标值，删除所有具有目标值的叶子节点。当删除叶子节点后，其父节点如果变成叶子节点且具有目标值，也需要继续删除，直到无法再删除。后序遍历实现此功能，通过递归处理左右子树，当遇到值为目标值且无子节点的节点时，删除该节点。

摘要由CSDN通过智能技术生成

Topic

Hash Table
Tree
Binary Tree
Depth-First Search
Breadth-First Search

Description

https://leetcode.com/problems/delete-leaves-with-a-given-value/

Given a binary tree root and an integer target, delete all the leaf nodes with value target.

Note that once you delete a leaf node with value target, if it’s parent node becomes a leaf node and has the value target, it should also be deleted (you need to continue doing that until you can’t).

Example 1:

Input: root = [1,2,3,2,null,2,4], target = 2
Output: [1,null,3,null,4]
Explanation: Leaf nodes in green with value (target = 2) are removed (Picture in left). 
After removing, new nodes become leaf nodes with value (target = 2) (Picture in center).

Example 2:

Input: root = [1,3,3,3,2], target = 3
Output: [1,3,null,null,2]

Example 3:

Input: root = [1,2,null,2,null,2], target = 2
Output: [1]
Explanation: Leaf nodes in green with value (target = 2) are removed at each step.

Example 4:

Input: root = [1,1,1], target = 1
Output: []

Example 5:

Input: root = [1,2,3], target = 1
Output: [1,2,3]

Constraints:

1 <= target <= 1000
The given binary tree will have between 1 and 3000 nodes.
Each node’s value is between [1, 1000].

Analysis

用到后序遍历模式。

Submission

import com.lun.util.BinaryTree.TreeNode;

public class DeleteLeavesWithAGivenValue {
    public TreeNode removeLeafNodes(TreeNode root, int target) {
    	if(root == null) return null;
    	root.left = removeLeafNodes(root.left, target);
    	root.right = removeLeafNodes(root.right, target);
    	if(root.left == null && root.right == null && root.val == target)
    		return null;
    	return root;
    }
}

Test

import static org.junit.Assert.*;
import org.junit.Test;

import com.lun.util.BinaryTree;
import com.lun.util.BinaryTree.TreeNode;

public class DeleteLeavesWithAGivenValueTest {

    @Test
    public void test() {
        DeleteLeavesWithAGivenValue dObj = new DeleteLeavesWithAGivenValue();

        TreeNode root1 = BinaryTree.of(1, 2, 3, 2, null, 2, 4);
        TreeNode expected1 = BinaryTree.of(1, null, 3, null, 4);
        assertTrue(BinaryTree.equals(dObj.removeLeafNodes(root1, 2), expected1));
        
        TreeNode root2 = BinaryTree.of(1, 3, 3, 3, 2);
        TreeNode expected2 = BinaryTree.of(1, 3, null, null, 2);
        assertTrue(BinaryTree.equals(dObj.removeLeafNodes(root2, 3), expected2));
        
        TreeNode root3 = BinaryTree.of(1, 2, null, 2, null, 2);
        TreeNode expected3 = BinaryTree.of(1);
        assertTrue(BinaryTree.equals(dObj.removeLeafNodes(root3, 2), expected3));
        
        TreeNode root4 = BinaryTree.of(1, 1, 1);
        TreeNode expected4 = null;
        assertTrue(BinaryTree.equals(dObj.removeLeafNodes(root4, 1), expected4));
        
        TreeNode root5 = BinaryTree.of(1, 2, 3);
        TreeNode expected5 = BinaryTree.of(1, 2, 3);
        assertTrue(BinaryTree.equals(dObj.removeLeafNodes(root5, 1), expected5));
    }
}