Skip to content

Commit 9d0680d

Browse files
yanglbmeyanglbme
authored
feat: update solutions to lc problem: No.0872
No.0872.Leaf-Similar Trees
1 parent 6182124 commit 9d0680d

File tree

6 files changed

+196
-124
lines changed

6 files changed

+196
-124
lines changed

‎solution/0800-0899/0872.Leaf-Similar Trees/README.md

Lines changed: 67 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -65,19 +65,14 @@
6565
# self.left = left
6666
# self.right = right
6767
class Solution:
68-
def leafSimilar(self, root1: TreeNode, root2: TreeNode) -> bool:
69-
def dfs(root, leaves):
68+
def leafSimilar(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> bool:
69+
def dfs(root):
7070
if root is None:
71-
return
72-
if root.left is None and root.right is None:
73-
leaves.append(root.val)
74-
return
75-
dfs(root.left, leaves)
76-
dfs(root.right, leaves)
77-
l1, l2 = [], []
78-
dfs(root1, l1)
79-
dfs(root2, l2)
80-
return l1 == l2
71+
return []
72+
ans = dfs(root.left) + dfs(root.right)
73+
return ans or [root.val]
74+
75+
return dfs(root1) == dfs(root2)
8176
```
8277

8378
### **Java**
@@ -102,50 +97,81 @@ class Solution:
10297
*/
10398
class Solution {
10499
public boolean leafSimilar(TreeNode root1, TreeNode root2) {
105-
List<Integer> l1 = new ArrayList<>();
106-
List<Integer> l2 = new ArrayList<>();
107-
dfs(root1, l1);
108-
dfs(root2, l2);
100+
List<Integer> l1 = dfs(root1);
101+
List<Integer> l2 = dfs(root2);
109102
return l1.equals(l2);
110103
}
111104

112-
private void dfs(TreeNode root, List<Integer> leaves) {
113-
if (root == null) return;
114-
if (root.left == null && root.right == null) {
115-
leaves.add(root.val);
116-
return;
105+
private List<Integer> dfs(TreeNode root) {
106+
if (root == null) {
107+
return new ArrayList<>();
108+
}
109+
List<Integer> ans = dfs(root.left);
110+
ans.addAll(dfs(root.right));
111+
if (ans.isEmpty()) {
112+
ans.add(root.val);
117113
}
118-
dfs(root.left, leaves);
119-
dfs(root.right, leaves);
114+
return ans;
120115
}
121116
}
122117
```
123118

119+
### **C++**
120+
121+
```cpp
122+
/**
123+
* Definition for a binary tree node.
124+
* struct TreeNode {
125+
* int val;
126+
* TreeNode *left;
127+
* TreeNode *right;
128+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
129+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
130+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
131+
* };
132+
*/
133+
class Solution {
134+
public:
135+
bool leafSimilar(TreeNode* root1, TreeNode* root2) {
136+
return dfs(root1) == dfs(root2);
137+
}
138+
139+
vector<int> dfs(TreeNode* root) {
140+
if (!root) return {};
141+
auto ans = dfs(root->left);
142+
auto right = dfs(root->right);
143+
ans.insert(ans.end(), right.begin(), right.end());
144+
if (ans.empty()) ans.push_back(root->val);
145+
return ans;
146+
}
147+
};
148+
```
149+
124150
### **Go**
125151

126152
```go
153+
/**
154+
* Definition for a binary tree node.
155+
* type TreeNode struct {
156+
* Val int
157+
* Left *TreeNode
158+
* Right *TreeNode
159+
* }
160+
*/
127161
func leafSimilar(root1 *TreeNode, root2 *TreeNode) bool {
128-
var l1, l2 []int
129-
if root1 != nil {
130-
dfs(root1, &l1)
131-
}
132-
if root2 != nil {
133-
dfs(root2, &l2)
134-
}
135-
return reflect.DeepEqual(l1, l2)
136-
}
137-
138-
func dfs(root *TreeNode, leaves *[]int) {
139-
if root.Left == nil && root.Right == nil {
140-
*leaves = append(*leaves, root.Val)
141-
} else {
142-
if root.Left != nil {
143-
dfs(root.Left, leaves)
162+
var dfs func(*TreeNode) []int
163+
dfs = func(root *TreeNode) []int {
164+
if root == nil {
165+
return []int{}
144166
}
145-
if root.Right != nil {
146-
dfs(root.Right, leaves)
167+
ans := dfs(root.Left)
168+
ans = append(ans, dfs(root.Right)...)
169+
if len(ans) == 0 {
170+
ans = append(ans, root.Val)
147171
}
172+
return ans
148173
}
174+
return reflect.DeepEqual(dfs(root1), dfs(root2))
149175
}
150176
```
151177

‎solution/0800-0899/0872.Leaf-Similar Trees/README_EN.md

Lines changed: 67 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -51,19 +51,14 @@
5151
# self.left = left
5252
# self.right = right
5353
class Solution:
54-
def leafSimilar(self, root1: TreeNode, root2: TreeNode) -> bool:
55-
def dfs(root, leaves):
54+
def leafSimilar(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> bool:
55+
def dfs(root):
5656
if root is None:
57-
return
58-
if root.left is None and root.right is None:
59-
leaves.append(root.val)
60-
return
61-
dfs(root.left, leaves)
62-
dfs(root.right, leaves)
63-
l1, l2 = [], []
64-
dfs(root1, l1)
65-
dfs(root2, l2)
66-
return l1 == l2
57+
return []
58+
ans = dfs(root.left) + dfs(root.right)
59+
return ans or [root.val]
60+
61+
return dfs(root1) == dfs(root2)
6762
```
6863

6964
### **Java**
@@ -86,50 +81,81 @@ class Solution:
8681
*/
8782
class Solution {
8883
public boolean leafSimilar(TreeNode root1, TreeNode root2) {
89-
List<Integer> l1 = new ArrayList<>();
90-
List<Integer> l2 = new ArrayList<>();
91-
dfs(root1, l1);
92-
dfs(root2, l2);
84+
List<Integer> l1 = dfs(root1);
85+
List<Integer> l2 = dfs(root2);
9386
return l1.equals(l2);
9487
}
9588

96-
private void dfs(TreeNode root, List<Integer> leaves) {
97-
if (root == null) return;
98-
if (root.left == null && root.right == null) {
99-
leaves.add(root.val);
100-
return;
89+
private List<Integer> dfs(TreeNode root) {
90+
if (root == null) {
91+
return new ArrayList<>();
92+
}
93+
List<Integer> ans = dfs(root.left);
94+
ans.addAll(dfs(root.right));
95+
if (ans.isEmpty()) {
96+
ans.add(root.val);
10197
}
102-
dfs(root.left, leaves);
103-
dfs(root.right, leaves);
98+
return ans;
10499
}
105100
}
106101
```
107102

103+
### **C++**
104+
105+
```cpp
106+
/**
107+
* Definition for a binary tree node.
108+
* struct TreeNode {
109+
* int val;
110+
* TreeNode *left;
111+
* TreeNode *right;
112+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
113+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
114+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
115+
* };
116+
*/
117+
class Solution {
118+
public:
119+
bool leafSimilar(TreeNode* root1, TreeNode* root2) {
120+
return dfs(root1) == dfs(root2);
121+
}
122+
123+
vector<int> dfs(TreeNode* root) {
124+
if (!root) return {};
125+
auto ans = dfs(root->left);
126+
auto right = dfs(root->right);
127+
ans.insert(ans.end(), right.begin(), right.end());
128+
if (ans.empty()) ans.push_back(root->val);
129+
return ans;
130+
}
131+
};
132+
```
133+
108134
### **Go**
109135

110136
```go
137+
/**
138+
* Definition for a binary tree node.
139+
* type TreeNode struct {
140+
* Val int
141+
* Left *TreeNode
142+
* Right *TreeNode
143+
* }
144+
*/
111145
func leafSimilar(root1 *TreeNode, root2 *TreeNode) bool {
112-
var l1, l2 []int
113-
if root1 != nil {
114-
dfs(root1, &l1)
115-
}
116-
if root2 != nil {
117-
dfs(root2, &l2)
118-
}
119-
return reflect.DeepEqual(l1, l2)
120-
}
121-
122-
func dfs(root *TreeNode, leaves *[]int) {
123-
if root.Left == nil && root.Right == nil {
124-
*leaves = append(*leaves, root.Val)
125-
} else {
126-
if root.Left != nil {
127-
dfs(root.Left, leaves)
146+
var dfs func(*TreeNode) []int
147+
dfs = func(root *TreeNode) []int {
148+
if root == nil {
149+
return []int{}
128150
}
129-
if root.Right != nil {
130-
dfs(root.Right, leaves)
151+
ans := dfs(root.Left)
152+
ans = append(ans, dfs(root.Right)...)
153+
if len(ans) == 0 {
154+
ans = append(ans, root.Val)
131155
}
156+
return ans
132157
}
158+
return reflect.DeepEqual(dfs(root1), dfs(root2))
133159
}
134160
```
135161

‎solution/0800-0899/0872.Leaf-Similar Trees/Solution.cpp

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
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+
bool leafSimilar(TreeNode* root1, TreeNode* root2) {
15+
return dfs(root1) == dfs(root2);
16+
}
17+
18+
vector<int> dfs(TreeNode* root) {
19+
if (!root) return {};
20+
auto ans = dfs(root->left);
21+
auto right = dfs(root->right);
22+
ans.insert(ans.end(), right.begin(), right.end());
23+
if (ans.empty()) ans.push_back(root->val);
24+
return ans;
25+
}
26+
};

‎solution/0800-0899/0872.Leaf-Similar Trees/Solution.go

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1,23 +1,23 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* type TreeNode struct {
4+
* Val int
5+
* Left *TreeNode
6+
* Right *TreeNode
7+
* }
8+
*/
19
func leafSimilar(root1 *TreeNode, root2 *TreeNode) bool {
2-
var l1, l2 []int
3-
if root1 != nil {
4-
dfs(root1, &l1)
5-
}
6-
if root2 != nil {
7-
dfs(root2, &l2)
8-
}
9-
return reflect.DeepEqual(l1, l2)
10-
}
11-
12-
func dfs(root *TreeNode, leaves *[]int) {
13-
if root.Left == nil && root.Right == nil {
14-
*leaves = append(*leaves, root.Val)
15-
} else {
16-
if root.Left != nil {
17-
dfs(root.Left, leaves)
10+
var dfs func(*TreeNode) []int
11+
dfs = func(root *TreeNode) []int {
12+
if root == nil {
13+
return []int{}
1814
}
19-
if root.Right != nil {
20-
dfs(root.Right, leaves)
15+
ans := dfs(root.Left)
16+
ans = append(ans, dfs(root.Right)...)
17+
if len(ans) == 0 {
18+
ans = append(ans, root.Val)
2119
}
20+
return ans
2221
}
23-
}
22+
return reflect.DeepEqual(dfs(root1), dfs(root2))
23+
}

‎solution/0800-0899/0872.Leaf-Similar Trees/Solution.java

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -15,20 +15,20 @@
1515
*/
1616
class Solution {
1717
public boolean leafSimilar(TreeNode root1, TreeNode root2) {
18-
List<Integer> l1 = new ArrayList<>();
19-
List<Integer> l2 = new ArrayList<>();
20-
dfs(root1, l1);
21-
dfs(root2, l2);
18+
List<Integer> l1 = dfs(root1);
19+
List<Integer> l2 = dfs(root2);
2220
return l1.equals(l2);
2321
}
2422

25-
private void dfs(TreeNode root, List<Integer> leaves) {
26-
if (root == null) return;
27-
if (root.left == null && root.right == null) {
28-
leaves.add(root.val);
29-
return;
23+
private List<Integer> dfs(TreeNode root) {
24+
if (root == null) {
25+
return new ArrayList<>();
3026
}
31-
dfs(root.left, leaves);
32-
dfs(root.right, leaves);
27+
List<Integer> ans = dfs(root.left);
28+
ans.addAll(dfs(root.right));
29+
if (ans.isEmpty()) {
30+
ans.add(root.val);
31+
}
32+
return ans;
3333
}
3434
}

0 commit comments

Comments
 (0)