Skip to content

Commit 092fa81

Browse files
yanglbmeyanglbme
committedDec 27, 2021
feat: add solutions to lc problem: No.1325
No.1325.Delete Leaves With a Given Value
·
v0.3.0v0.1.9
1 parent c93121b commit 092fa81

File tree

6 files changed

+371
-2
lines changed

6 files changed

+371
-2
lines changed
 

‎solution/1300-1399/1325.Delete Leaves With a Given Value/README.md

+128-1
Original file line numberDiff line numberDiff line change
@@ -67,22 +67,149 @@
6767

6868
<!-- 这里可写通用的实现逻辑 -->
6969

70+
后序遍历，遇到叶子节点值为 target 的时候，将叶子节点置为 null。此过程使用一个父节点来完成。
71+
7072
<!-- tabs:start -->
7173

7274
### **Python3**
7375

7476
<!-- 这里可写当前语言的特殊实现逻辑 -->
7577

7678
```python
77-
79+
# Definition for a binary tree node.
80+
# class TreeNode:
81+
# def __init__(self, val=0, left=None, right=None):
82+
# self.val = val
83+
# self.left = left
84+
# self.right = right
85+
class Solution:
86+
def removeLeafNodes(self, root: Optional[TreeNode], target: int) -> Optional[TreeNode]:
87+
def dfs(root, prev):
88+
if root is None:
89+
return
90+
dfs(root.left, root)
91+
dfs(root.right, root)
92+
if root.left is None and root.right is None and root.val == target:
93+
if prev.left == root:
94+
prev.left = None
95+
else:
96+
prev.right = None
97+
98+
p = TreeNode(val=0, left=root)
99+
dfs(root, p)
100+
return p.left
78101
```
79102

80103
### **Java**
81104

82105
<!-- 这里可写当前语言的特殊实现逻辑 -->
83106

84107
```java
108+
/**
109+
* Definition for a binary tree node.
110+
* public class TreeNode {
111+
* int val;
112+
* TreeNode left;
113+
* TreeNode right;
114+
* TreeNode() {}
115+
* TreeNode(int val) { this.val = val; }
116+
* TreeNode(int val, TreeNode left, TreeNode right) {
117+
* this.val = val;
118+
* this.left = left;
119+
* this.right = right;
120+
* }
121+
* }
122+
*/
123+
class Solution {
124+
public TreeNode removeLeafNodes(TreeNode root, int target) {
125+
TreeNode p = new TreeNode(0, root, null);
126+
dfs(root, p, target);
127+
return p.left;
128+
}
129+
130+
private void dfs(TreeNode root, TreeNode prev, int target) {
131+
if (root == null) {
132+
return;
133+
}
134+
dfs(root.left, root, target);
135+
dfs(root.right, root, target);
136+
if (root.left == null && root.right == null && root.val == target) {
137+
if (prev.left == root) {
138+
prev.left = null;
139+
} else {
140+
prev.right = null;
141+
}
142+
}
143+
}
144+
}
145+
```
146+
147+
### **C++**
148+
149+
```cpp
150+
/**
151+
* Definition for a binary tree node.
152+
* struct TreeNode {
153+
* int val;
154+
* TreeNode *left;
155+
* TreeNode *right;
156+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
157+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
158+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
159+
* };
160+
*/
161+
class Solution {
162+
public:
163+
TreeNode* removeLeafNodes(TreeNode* root, int target) {
164+
TreeNode* p = new TreeNode(0, root, nullptr);
165+
dfs(root, p, target);
166+
return p->left;
167+
}
168+
169+
void dfs(TreeNode* root, TreeNode* prev, int target) {
170+
if (!root) return;
171+
dfs(root->left, root, target);
172+
dfs(root->right, root, target);
173+
if (!root->left && !root->right && root->val == target)
174+
{
175+
if (prev->left == root) prev->left = nullptr;
176+
else prev->right = nullptr;
177+
}
178+
}
179+
};
180+
```
85181

182+
### **Go**
183+
184+
```go
185+
/**
186+
* Definition for a binary tree node.
187+
* type TreeNode struct {
188+
* Val int
189+
* Left *TreeNode
190+
* Right *TreeNode
191+
* }
192+
*/
193+
func removeLeafNodes(root *TreeNode, target int) *TreeNode {
194+
p := &TreeNode{0, root, nil}
195+
var dfs func(root, prev *TreeNode)
196+
dfs = func(root, prev *TreeNode) {
197+
if root == nil {
198+
return
199+
}
200+
dfs(root.Left, root)
201+
dfs(root.Right, root)
202+
if root.Left == nil && root.Right == nil && root.Val == target {
203+
if prev.Left == root {
204+
prev.Left = nil
205+
} else {
206+
prev.Right = nil
207+
}
208+
}
209+
}
210+
dfs(root, p)
211+
return p.Left
212+
}
86213
```
87214

88215
### **...**

‎solution/1300-1399/1325.Delete Leaves With a Given Value/README_EN.md

+126-1
Original file line numberDiff line numberDiff line change
@@ -69,13 +69,138 @@ After removing, new nodes become leaf nodes with value (target = 2) (Picture in
6969
### **Python3**
7070

7171
```python
72-
72+
# Definition for a binary tree node.
73+
# class TreeNode:
74+
# def __init__(self, val=0, left=None, right=None):
75+
# self.val = val
76+
# self.left = left
77+
# self.right = right
78+
class Solution:
79+
def removeLeafNodes(self, root: Optional[TreeNode], target: int) -> Optional[TreeNode]:
80+
def dfs(root, prev):
81+
if root is None:
82+
return
83+
dfs(root.left, root)
84+
dfs(root.right, root)
85+
if root.left is None and root.right is None and root.val == target:
86+
if prev.left == root:
87+
prev.left = None
88+
else:
89+
prev.right = None
90+
91+
p = TreeNode(val=0, left=root)
92+
dfs(root, p)
93+
return p.left
7394
```
7495

7596
### **Java**
7697

7798
```java
99+
/**
100+
* Definition for a binary tree node.
101+
* public class TreeNode {
102+
* int val;
103+
* TreeNode left;
104+
* TreeNode right;
105+
* TreeNode() {}
106+
* TreeNode(int val) { this.val = val; }
107+
* TreeNode(int val, TreeNode left, TreeNode right) {
108+
* this.val = val;
109+
* this.left = left;
110+
* this.right = right;
111+
* }
112+
* }
113+
*/
114+
class Solution {
115+
public TreeNode removeLeafNodes(TreeNode root, int target) {
116+
TreeNode p = new TreeNode(0, root, null);
117+
dfs(root, p, target);
118+
return p.left;
119+
}
120+
121+
private void dfs(TreeNode root, TreeNode prev, int target) {
122+
if (root == null) {
123+
return;
124+
}
125+
dfs(root.left, root, target);
126+
dfs(root.right, root, target);
127+
if (root.left == null && root.right == null && root.val == target) {
128+
if (prev.left == root) {
129+
prev.left = null;
130+
} else {
131+
prev.right = null;
132+
}
133+
}
134+
}
135+
}
136+
```
137+
138+
### **C++**
139+
140+
```cpp
141+
/**
142+
* Definition for a binary tree node.
143+
* struct TreeNode {
144+
* int val;
145+
* TreeNode *left;
146+
* TreeNode *right;
147+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
148+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
149+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
150+
* };
151+
*/
152+
class Solution {
153+
public:
154+
TreeNode* removeLeafNodes(TreeNode* root, int target) {
155+
TreeNode* p = new TreeNode(0, root, nullptr);
156+
dfs(root, p, target);
157+
return p->left;
158+
}
159+
160+
void dfs(TreeNode* root, TreeNode* prev, int target) {
161+
if (!root) return;
162+
dfs(root->left, root, target);
163+
dfs(root->right, root, target);
164+
if (!root->left && !root->right && root->val == target)
165+
{
166+
if (prev->left == root) prev->left = nullptr;
167+
else prev->right = nullptr;
168+
}
169+
}
170+
};
171+
```
78172

173+
### **Go**
174+
175+
```go
176+
/**
177+
* Definition for a binary tree node.
178+
* type TreeNode struct {
179+
* Val int
180+
* Left *TreeNode
181+
* Right *TreeNode
182+
* }
183+
*/
184+
func removeLeafNodes(root *TreeNode, target int) *TreeNode {
185+
p := &TreeNode{0, root, nil}
186+
var dfs func(root, prev *TreeNode)
187+
dfs = func(root, prev *TreeNode) {
188+
if root == nil {
189+
return
190+
}
191+
dfs(root.Left, root)
192+
dfs(root.Right, root)
193+
if root.Left == nil && root.Right == nil && root.Val == target {
194+
if prev.Left == root {
195+
prev.Left = nil
196+
} else {
197+
prev.Right = nil
198+
}
199+
}
200+
}
201+
dfs(root, p)
202+
return p.Left
203+
}
79204
```
80205

81206
### **...**

‎solution/1300-1399/1325.Delete Leaves With a Given Value/Solution.cpp

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
TreeNode* removeLeafNodes(TreeNode* root, int target) {
15+
TreeNode* p = new TreeNode(0, root, nullptr);
16+
dfs(root, p, target);
17+
return p->left;
18+
}
19+
20+
void dfs(TreeNode* root, TreeNode* prev, int target) {
21+
if (!root) return;
22+
dfs(root->left, root, target);
23+
dfs(root->right, root, target);
24+
if (!root->left && !root->right && root->val == target)
25+
{
26+
if (prev->left == root) prev->left = nullptr;
27+
else prev->right = nullptr;
28+
}
29+
}
30+
};

‎solution/1300-1399/1325.Delete Leaves With a Given Value/Solution.go

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* type TreeNode struct {
4+
* Val int
5+
* Left *TreeNode
6+
* Right *TreeNode
7+
* }
8+
*/
9+
func removeLeafNodes(root *TreeNode, target int) *TreeNode {
10+
p := &TreeNode{0, root, nil}
11+
var dfs func(root, prev *TreeNode)
12+
dfs = func(root, prev *TreeNode) {
13+
if root == nil {
14+
return
15+
}
16+
dfs(root.Left, root)
17+
dfs(root.Right, root)
18+
if root.Left == nil && root.Right == nil && root.Val == target {
19+
if prev.Left == root {
20+
prev.Left = nil
21+
} else {
22+
prev.Right = nil
23+
}
24+
}
25+
}
26+
dfs(root, p)
27+
return p.Left
28+
}

‎solution/1300-1399/1325.Delete Leaves With a Given Value/Solution.java

+37
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* public class TreeNode {
4+
* int val;
5+
* TreeNode left;
6+
* TreeNode right;
7+
* TreeNode() {}
8+
* TreeNode(int val) { this.val = val; }
9+
* TreeNode(int val, TreeNode left, TreeNode right) {
10+
* this.val = val;
11+
* this.left = left;
12+
* this.right = right;
13+
* }
14+
* }
15+
*/
16+
class Solution {
17+
public TreeNode removeLeafNodes(TreeNode root, int target) {
18+
TreeNode p = new TreeNode(0, root, null);
19+
dfs(root, p, target);
20+
return p.left;
21+
}
22+
23+
private void dfs(TreeNode root, TreeNode prev, int target) {
24+
if (root == null) {
25+
return;
26+
}
27+
dfs(root.left, root, target);
28+
dfs(root.right, root, target);
29+
if (root.left == null && root.right == null && root.val == target) {
30+
if (prev.left == root) {
31+
prev.left = null;
32+
} else {
33+
prev.right = null;
34+
}
35+
}
36+
}
37+
}

0 commit comments

Comments
 (0)
Please sign in to comment.