Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit de6fb69

Browse files
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
### **...**
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)

AltStyle によって変換されたページ (->オリジナル) /