Delete leaves with a given value

Author: volodimyr

1325.delete_leaves_with_a_given_value/delete.go

@@ -0,0 +1,50 @@
+// 1325. Delete Leaves With a Given Value
+// Topics: 'Depth-First Search', 'Tree', 'Binary Search Tree', 'Binary Tree'
+// Level: 'Medium'
+
+// 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 its parent node becomes a leaf node and has the value target, it should also be deleted (you need to continue doing that until you cannot).
+
+// 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.
+
+// Constraints:
+
+//     The number of nodes in the tree is in the range [1, 3000].
+//     1 <= Node.val, target <= 1000
+
+package deleteleaveswithagivenvalue
+
+func removeLeafNodes(root *TreeNode, target int) *TreeNode {
+	if root == nil {
+		return nil
+	}
+	root.Left = removeLeafNodes(root.Left, target)
+	root.Right = removeLeafNodes(root.Right, target)
+	if root.Left == nil && root.Right == nil && root.Val == target {
+		return nil
+	}
+	return root
+}
+
+type TreeNode struct {
+	Right *TreeNode
+	Left  *TreeNode
+	Val   int
+}

1325.delete_leaves_with_a_given_value/delete_test.go

@@ -0,0 +1,330 @@
+package deleteleaveswithagivenvalue
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestRemoveLeafNodes(t *testing.T) {
+	tests := []struct {
+		name   string
+		root   *TreeNode
+		target int
+		want   *TreeNode
+	}{
+		{
+			name: "example 1",
+			//     1              1
+			//    / \              \
+			//   2   3     =>       3
+			//  /   / \              \
+			// 2   2   4              4
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:  2,
+					Left: &TreeNode{Val: 2},
+				},
+				Right: &TreeNode{
+					Val:   3,
+					Left:  &TreeNode{Val: 2},
+					Right: &TreeNode{Val: 4},
+				},
+			},
+			target: 2,
+			want: &TreeNode{
+				Val:  1,
+				Left: nil,
+				Right: &TreeNode{
+					Val:   3,
+					Left:  nil,
+					Right: &TreeNode{Val: 4},
+				},
+			},
+		},
+		{
+			name: "example 2",
+			//     1          1
+			//    / \        /
+			//   3   3  =>  3
+			//  / \          \
+			// 3   2          2
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:   3,
+					Left:  &TreeNode{Val: 3},
+					Right: &TreeNode{Val: 2},
+				},
+				Right: &TreeNode{Val: 3},
+			},
+			target: 3,
+			want: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:   3,
+					Left:  nil,
+					Right: &TreeNode{Val: 2},
+				},
+				Right: nil,
+			},
+		},
+		{
+			name: "example 3",
+			//   1          1
+			//  /
+			// 2      =>
+			// |
+			// 2
+			// |
+			// 2
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val: 2,
+					Left: &TreeNode{
+						Val:  2,
+						Left: &TreeNode{Val: 2},
+					},
+				},
+			},
+			target: 2,
+			want:   &TreeNode{Val: 1},
+		},
+		{
+			name: "single node matching target",
+			// 5  =>  (null)
+			root:   &TreeNode{Val: 5},
+			target: 5,
+			want:   nil,
+		},
+		{
+			name: "single node not matching target",
+			// 5  =>  5
+			root:   &TreeNode{Val: 5},
+			target: 3,
+			want:   &TreeNode{Val: 5},
+		},
+		{
+			name: "no nodes match target",
+			//   1        1
+			//  / \  =>  / \
+			// 2   3    2   3
+			root: &TreeNode{
+				Val:   1,
+				Left:  &TreeNode{Val: 2},
+				Right: &TreeNode{Val: 3},
+			},
+			target: 5,
+			want: &TreeNode{
+				Val:   1,
+				Left:  &TreeNode{Val: 2},
+				Right: &TreeNode{Val: 3},
+			},
+		},
+		{
+			name: "all leaf nodes match target",
+			//     1            1
+			//    / \          / \
+			//   2   4   =>   2   4
+			//  / \ / \
+			// 3  3 3  3
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:   2,
+					Left:  &TreeNode{Val: 3},
+					Right: &TreeNode{Val: 3},
+				},
+				Right: &TreeNode{
+					Val:   4,
+					Left:  &TreeNode{Val: 3},
+					Right: &TreeNode{Val: 3},
+				},
+			},
+			target: 3,
+			want: &TreeNode{
+				Val:   1,
+				Left:  &TreeNode{Val: 2},
+				Right: &TreeNode{Val: 4},
+			},
+		},
+		{
+			name: "cascading deletion left side",
+			//    10           10
+			//   /  \           \
+			//  5   20   =>     20
+			//  |
+			//  5
+			//  |
+			//  5
+			root: &TreeNode{
+				Val: 10,
+				Left: &TreeNode{
+					Val: 5,
+					Left: &TreeNode{
+						Val:  5,
+						Left: &TreeNode{Val: 5},
+					},
+				},
+				Right: &TreeNode{Val: 20},
+			},
+			target: 5,
+			want: &TreeNode{
+				Val:   10,
+				Left:  nil,
+				Right: &TreeNode{Val: 20},
+			},
+		},
+		{
+			name: "cascading deletion right side",
+			//   10          10
+			//  /  \        /
+			// 20   5  =>  20
+			//      |
+			//      5
+			//      |
+			//      5
+			root: &TreeNode{
+				Val:  10,
+				Left: &TreeNode{Val: 20},
+				Right: &TreeNode{
+					Val: 5,
+					Right: &TreeNode{
+						Val:   5,
+						Right: &TreeNode{Val: 5},
+					},
+				},
+			},
+			target: 5,
+			want: &TreeNode{
+				Val:   10,
+				Left:  &TreeNode{Val: 20},
+				Right: nil,
+			},
+		},
+		{
+			name: "target in middle nodes only",
+			//   1          1
+			//  / \        / \
+			// 2   5  =>  2   5
+			/// \        / \
+			//3   4      3   4
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:   2,
+					Left:  &TreeNode{Val: 3},
+					Right: &TreeNode{Val: 4},
+				},
+				Right: &TreeNode{Val: 5},
+			},
+			target: 2,
+			want: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:   2,
+					Left:  &TreeNode{Val: 3},
+					Right: &TreeNode{Val: 4},
+				},
+				Right: &TreeNode{Val: 5},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := removeLeafNodes(tt.root, tt.target)
+			if !treesEqual(got, tt.want) {
+				t.Errorf("removeLeafNodes() = %v, want %v", treeToSlice(got), treeToSlice(tt.want))
+			}
+		})
+	}
+}
+
+func treesEqual(t1, t2 *TreeNode) bool {
+	if t1 == nil && t2 == nil {
+		return true
+	}
+	if t1 == nil || t2 == nil {
+		return false
+	}
+	if t1.Val != t2.Val {
+		return false
+	}
+	return treesEqual(t1.Left, t2.Left) && treesEqual(t1.Right, t2.Right)
+}
+
+func treeToSlice(root *TreeNode) []interface{} {
+	if root == nil {
+		return []interface{}{}
+	}
+	result := []interface{}{}
+	queue := []*TreeNode{root}
+	for len(queue) > 0 {
+		node := queue[0]
+		queue = queue[1:]
+		if node == nil {
+			result = append(result, nil)
+		} else {
+			result = append(result, node.Val)
+			queue = append(queue, node.Left)
+			queue = append(queue, node.Right)
+		}
+	}
+	for len(result) > 0 && result[len(result)-1] == nil {
+		result = result[:len(result)-1]
+	}
+	return result
+}
+
+func TestTraversal(t *testing.T) {
+	tests := []struct {
+		name   string
+		root   *TreeNode
+		target int
+		want   *TreeNode
+	}{
+		{
+			name:   "nil root",
+			root:   nil,
+			target: 1,
+			want:   nil,
+		},
+		{
+			name: "leaf node matches target",
+			// 5  =>  (null)
+			root:   &TreeNode{Val: 5},
+			target: 5,
+			want:   nil,
+		},
+		{
+			name: "leaf node does not match target",
+			// 5  =>  5
+			root:   &TreeNode{Val: 5},
+			target: 3,
+			want:   &TreeNode{Val: 5},
+		},
+		{
+			name: "parent becomes leaf after child deletion",
+			// 2      (null)
+			// |  =>
+			// 2
+			root: &TreeNode{
+				Val:  2,
+				Left: &TreeNode{Val: 2},
+			},
+			target: 2,
+			want:   nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := removeLeafNodes(tt.root, tt.target)
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("traversal() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}