Skip to content

Commit de6fb69

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0366
0366.Find Leaves of Binary Tree
1 parent dfdf1bb commit de6fb69

File tree

6 files changed

+455
-4
lines changed

6 files changed

+455
-4
lines changed

‎solution/0300-0399/0366.Find Leaves of Binary Tree/README.md

Lines changed: 156 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -53,27 +53,181 @@
5353
<pre> []
5454
</pre>
5555

56-
5756
## 解法
5857

5958
<!-- 这里可写通用的实现逻辑 -->
6059

60+
添加前置节点 prev，初始时 `prev.left = root`。
61+
6162
<!-- tabs:start -->
6263

6364
### **Python3**
6465

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

6768
```python
68-
69+
# Definition for a binary tree node.
70+
# class TreeNode:
71+
# def __init__(self, val=0, left=None, right=None):
72+
# self.val = val
73+
# self.left = left
74+
# self.right = right
75+
class Solution:
76+
def findLeaves(self, root: TreeNode) -> List[List[int]]:
77+
def dfs(root, prev, t):
78+
if root is None:
79+
return
80+
if root.left is None and root.right is None:
81+
t.append(root.val)
82+
if prev.left == root:
83+
prev.left = None
84+
else:
85+
prev.right = None
86+
dfs(root.left, root, t)
87+
dfs(root.right, root, t)
88+
89+
res = []
90+
prev = TreeNode(left=root)
91+
while prev.left:
92+
t = []
93+
dfs(prev.left, prev, t)
94+
res.append(t)
95+
return res
6996
```
7097

7198
### **Java**
7299

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

75102
```java
103+
/**
104+
* Definition for a binary tree node.
105+
* public class TreeNode {
106+
* int val;
107+
* TreeNode left;
108+
* TreeNode right;
109+
* TreeNode() {}
110+
* TreeNode(int val) { this.val = val; }
111+
* TreeNode(int val, TreeNode left, TreeNode right) {
112+
* this.val = val;
113+
* this.left = left;
114+
* this.right = right;
115+
* }
116+
* }
117+
*/
118+
class Solution {
119+
public List<List<Integer>> findLeaves(TreeNode root) {
120+
List<List<Integer>> res = new ArrayList<>();
121+
TreeNode prev = new TreeNode(0, root, null);
122+
while (prev.left != null) {
123+
List<Integer> t = new ArrayList<>();
124+
dfs(prev.left, prev, t);
125+
res.add(t);
126+
}
127+
return res;
128+
}
129+
130+
private void dfs(TreeNode root, TreeNode prev, List<Integer> t) {
131+
if (root == null) {
132+
return;
133+
}
134+
if (root.left == null && root.right == null) {
135+
t.add(root.val);
136+
if (prev.left == root) {
137+
prev.left = null;
138+
} else {
139+
prev.right = null;
140+
}
141+
}
142+
dfs(root.left, root, t);
143+
dfs(root.right, root, t);
144+
}
145+
}
146+
```
147+
148+
### **C++**
149+
150+
```cpp
151+
/**
152+
* Definition for a binary tree node.
153+
* struct TreeNode {
154+
* int val;
155+
* TreeNode *left;
156+
* TreeNode *right;
157+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
158+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
159+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
160+
* };
161+
*/
162+
class Solution {
163+
public:
164+
vector<vector<int>> findLeaves(TreeNode* root) {
165+
vector<vector<int>> res;
166+
TreeNode* prev = new TreeNode(0, root, nullptr);
167+
while (prev->left)
168+
{
169+
vector<int> t;
170+
dfs(prev->left, prev, t);
171+
res.push_back(t);
172+
}
173+
return res;
174+
}
175+
176+
void dfs(TreeNode* root, TreeNode* prev, vector<int>& t) {
177+
if (!root) return;
178+
if (!root->left && !root->right)
179+
{
180+
t.push_back(root->val);
181+
if (prev->left == root) prev->left = nullptr;
182+
else prev->right = nullptr;
183+
}
184+
dfs(root->left, root, t);
185+
dfs(root->right, root, t);
186+
}
187+
};
188+
```
76189
190+
### **Go**
191+
192+
```go
193+
/**
194+
* Definition for a binary tree node.
195+
* type TreeNode struct {
196+
* Val int
197+
* Left *TreeNode
198+
* Right *TreeNode
199+
* }
200+
*/
201+
func findLeaves(root *TreeNode) [][]int {
202+
prev := &TreeNode{
203+
Val: 0,
204+
Left: root,
205+
Right: nil,
206+
}
207+
var res [][]int
208+
for prev.Left != nil {
209+
var t []int
210+
dfs(prev.Left, prev, &t)
211+
res = append(res, t)
212+
}
213+
return res
214+
}
215+
216+
func dfs(root, prev *TreeNode, t *[]int) {
217+
if root == nil {
218+
return
219+
}
220+
if root.Left == nil && root.Right == nil {
221+
*t = append(*t, root.Val)
222+
if prev.Left == root {
223+
prev.Left = nil
224+
} else {
225+
prev.Right = nil
226+
}
227+
}
228+
dfs(root.Left, root, t)
229+
dfs(root.Right, root, t)
230+
}
77231
```
78232

79233
### **...**

‎solution/0300-0399/0366.Find Leaves of Binary Tree/README_EN.md

Lines changed: 154 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -37,21 +37,173 @@ Explanation:
3737
<li><code>1 &lt;= Node.val &lt;= 100</code></li>
3838
</ul>
3939

40-
4140
## Solutions
4241

4342
<!-- tabs:start -->
4443

4544
### **Python3**
4645

4746
```python
48-
47+
# Definition for a binary tree node.
48+
# class TreeNode:
49+
# def __init__(self, val=0, left=None, right=None):
50+
# self.val = val
51+
# self.left = left
52+
# self.right = right
53+
class Solution:
54+
def findLeaves(self, root: TreeNode) -> List[List[int]]:
55+
def dfs(root, prev, t):
56+
if root is None:
57+
return
58+
if root.left is None and root.right is None:
59+
t.append(root.val)
60+
if prev.left == root:
61+
prev.left = None
62+
else:
63+
prev.right = None
64+
dfs(root.left, root, t)
65+
dfs(root.right, root, t)
66+
67+
res = []
68+
prev = TreeNode(left=root)
69+
while prev.left:
70+
t = []
71+
dfs(prev.left, prev, t)
72+
res.append(t)
73+
return res
4974
```
5075

5176
### **Java**
5277

5378
```java
79+
/**
80+
* Definition for a binary tree node.
81+
* public class TreeNode {
82+
* int val;
83+
* TreeNode left;
84+
* TreeNode right;
85+
* TreeNode() {}
86+
* TreeNode(int val) { this.val = val; }
87+
* TreeNode(int val, TreeNode left, TreeNode right) {
88+
* this.val = val;
89+
* this.left = left;
90+
* this.right = right;
91+
* }
92+
* }
93+
*/
94+
class Solution {
95+
public List<List<Integer>> findLeaves(TreeNode root) {
96+
List<List<Integer>> res = new ArrayList<>();
97+
TreeNode prev = new TreeNode(0, root, null);
98+
while (prev.left != null) {
99+
List<Integer> t = new ArrayList<>();
100+
dfs(prev.left, prev, t);
101+
res.add(t);
102+
}
103+
return res;
104+
}
105+
106+
private void dfs(TreeNode root, TreeNode prev, List<Integer> t) {
107+
if (root == null) {
108+
return;
109+
}
110+
if (root.left == null && root.right == null) {
111+
t.add(root.val);
112+
if (prev.left == root) {
113+
prev.left = null;
114+
} else {
115+
prev.right = null;
116+
}
117+
}
118+
dfs(root.left, root, t);
119+
dfs(root.right, root, t);
120+
}
121+
}
122+
```
123+
124+
### **C++**
125+
126+
```cpp
127+
/**
128+
* Definition for a binary tree node.
129+
* struct TreeNode {
130+
* int val;
131+
* TreeNode *left;
132+
* TreeNode *right;
133+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
134+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
135+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
136+
* };
137+
*/
138+
class Solution {
139+
public:
140+
vector<vector<int>> findLeaves(TreeNode* root) {
141+
vector<vector<int>> res;
142+
TreeNode* prev = new TreeNode(0, root, nullptr);
143+
while (prev->left)
144+
{
145+
vector<int> t;
146+
dfs(prev->left, prev, t);
147+
res.push_back(t);
148+
}
149+
return res;
150+
}
151+
152+
void dfs(TreeNode* root, TreeNode* prev, vector<int>& t) {
153+
if (!root) return;
154+
if (!root->left && !root->right)
155+
{
156+
t.push_back(root->val);
157+
if (prev->left == root) prev->left = nullptr;
158+
else prev->right = nullptr;
159+
}
160+
dfs(root->left, root, t);
161+
dfs(root->right, root, t);
162+
}
163+
};
164+
```
54165
166+
### **Go**
167+
168+
```go
169+
/**
170+
* Definition for a binary tree node.
171+
* type TreeNode struct {
172+
* Val int
173+
* Left *TreeNode
174+
* Right *TreeNode
175+
* }
176+
*/
177+
func findLeaves(root *TreeNode) [][]int {
178+
prev := &TreeNode{
179+
Val: 0,
180+
Left: root,
181+
Right: nil,
182+
}
183+
var res [][]int
184+
for prev.Left != nil {
185+
var t []int
186+
dfs(prev.Left, prev, &t)
187+
res = append(res, t)
188+
}
189+
return res
190+
}
191+
192+
func dfs(root, prev *TreeNode, t *[]int) {
193+
if root == nil {
194+
return
195+
}
196+
if root.Left == nil && root.Right == nil {
197+
*t = append(*t, root.Val)
198+
if prev.Left == root {
199+
prev.Left = nil
200+
} else {
201+
prev.Right = nil
202+
}
203+
}
204+
dfs(root.Left, root, t)
205+
dfs(root.Right, root, t)
206+
}
55207
```
56208

57209
### **...**

‎solution/0300-0399/0366.Find Leaves of Binary Tree/Solution.cpp

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
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+
vector<vector<int>> findLeaves(TreeNode* root) {
15+
vector<vector<int>> res;
16+
TreeNode* prev = new TreeNode(0, root, nullptr);
17+
while (prev->left)
18+
{
19+
vector<int> t;
20+
dfs(prev->left, prev, t);
21+
res.push_back(t);
22+
}
23+
return res;
24+
}
25+
26+
void dfs(TreeNode* root, TreeNode* prev, vector<int>& t) {
27+
if (!root) return;
28+
if (!root->left && !root->right)
29+
{
30+
t.push_back(root->val);
31+
if (prev->left == root) prev->left = nullptr;
32+
else prev->right = nullptr;
33+
}
34+
dfs(root->left, root, t);
35+
dfs(root->right, root, t);
36+
}
37+
};

0 commit comments

Comments
 (0)