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 ff70914

Browse files
committed
feat: add solutions to lc problems: No.0543,0687
1 parent b35275e commit ff70914

File tree

12 files changed

+697
-17
lines changed

12 files changed

+697
-17
lines changed

‎solution/0500-0599/0543.Diameter of Binary Tree/README.md‎

Lines changed: 124 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -31,22 +31,145 @@
3131

3232
<!-- 这里可写通用的实现逻辑 -->
3333

34+
类似题目:[687. 最长同值路径](/solution/0600-0699/0687.Longest%20Univalue%20Path/README.md)
35+
3436
<!-- tabs:start -->
3537

3638
### **Python3**
3739

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

4042
```python
41-
43+
# Definition for a binary tree node.
44+
# class TreeNode:
45+
# def __init__(self, val=0, left=None, right=None):
46+
# self.val = val
47+
# self.left = left
48+
# self.right = right
49+
class Solution:
50+
def diameterOfBinaryTree(self, root: TreeNode) -> int:
51+
res = 0
52+
53+
def dfs(root):
54+
nonlocal res
55+
if root is None:
56+
return 0
57+
left, right = dfs(root.left), dfs(root.right)
58+
res = max(res, left + right)
59+
return 1 + max(left, right)
60+
61+
dfs(root)
62+
return res
4263
```
4364

4465
### **Java**
4566

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

4869
```java
70+
/**
71+
* Definition for a binary tree node.
72+
* public class TreeNode {
73+
* int val;
74+
* TreeNode left;
75+
* TreeNode right;
76+
* TreeNode() {}
77+
* TreeNode(int val) { this.val = val; }
78+
* TreeNode(int val, TreeNode left, TreeNode right) {
79+
* this.val = val;
80+
* this.left = left;
81+
* this.right = right;
82+
* }
83+
* }
84+
*/
85+
class Solution {
86+
private int res;
87+
88+
public int diameterOfBinaryTree(TreeNode root) {
89+
res = 0;
90+
dfs(root);
91+
return res;
92+
}
93+
94+
private int dfs(TreeNode root) {
95+
if (root == null) {
96+
return 0;
97+
}
98+
int left = dfs(root.left);
99+
int right = dfs(root.right);
100+
res = Math.max(res, left + right);
101+
return 1 + Math.max(left, right);
102+
}
103+
}
104+
```
105+
106+
### **C++**
107+
108+
```cpp
109+
/**
110+
* Definition for a binary tree node.
111+
* struct TreeNode {
112+
* int val;
113+
* TreeNode *left;
114+
* TreeNode *right;
115+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
116+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
117+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
118+
* };
119+
*/
120+
class Solution {
121+
public:
122+
int res;
123+
124+
int diameterOfBinaryTree(TreeNode* root) {
125+
res = 0;
126+
dfs(root);
127+
return res;
128+
}
129+
130+
int dfs(TreeNode* root) {
131+
if (!root) return 0;
132+
int left = dfs(root->left), right = dfs(root->right);
133+
res = max(res, left + right);
134+
return 1 + max(left, right);
135+
}
136+
};
137+
```
49138
139+
### **Go**
140+
141+
```go
142+
/**
143+
* Definition for a binary tree node.
144+
* type TreeNode struct {
145+
* Val int
146+
* Left *TreeNode
147+
* Right *TreeNode
148+
* }
149+
*/
150+
var res int
151+
152+
func diameterOfBinaryTree(root *TreeNode) int {
153+
res = 0
154+
dfs(root)
155+
return res
156+
}
157+
158+
func dfs(root *TreeNode) int {
159+
if root == nil {
160+
return 0
161+
}
162+
left, right := dfs(root.Left), dfs(root.Right)
163+
res = max(res, left+right)
164+
return 1 + max(left, right)
165+
}
166+
167+
func max(a, b int) int {
168+
if a > b {
169+
return a
170+
}
171+
return b
172+
}
50173
```
51174

52175
### **...**

‎solution/0500-0599/0543.Diameter of Binary Tree/README_EN.md‎

Lines changed: 124 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -37,18 +37,141 @@
3737

3838
## Solutions
3939

40+
Similar to problem [687. Longest Univalue Path](/solution/0600-0699/0687.Longest%20Univalue%20Path/README_EN.md).
41+
4042
<!-- tabs:start -->
4143

4244
### **Python3**
4345

4446
```python
45-
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 diameterOfBinaryTree(self, root: TreeNode) -> int:
55+
res = 0
56+
57+
def dfs(root):
58+
nonlocal res
59+
if root is None:
60+
return 0
61+
left, right = dfs(root.left), dfs(root.right)
62+
res = max(res, left + right)
63+
return 1 + max(left, right)
64+
65+
dfs(root)
66+
return res
4667
```
4768

4869
### **Java**
4970

5071
```java
72+
/**
73+
* Definition for a binary tree node.
74+
* public class TreeNode {
75+
* int val;
76+
* TreeNode left;
77+
* TreeNode right;
78+
* TreeNode() {}
79+
* TreeNode(int val) { this.val = val; }
80+
* TreeNode(int val, TreeNode left, TreeNode right) {
81+
* this.val = val;
82+
* this.left = left;
83+
* this.right = right;
84+
* }
85+
* }
86+
*/
87+
class Solution {
88+
private int res;
89+
90+
public int diameterOfBinaryTree(TreeNode root) {
91+
res = 0;
92+
dfs(root);
93+
return res;
94+
}
95+
96+
private int dfs(TreeNode root) {
97+
if (root == null) {
98+
return 0;
99+
}
100+
int left = dfs(root.left);
101+
int right = dfs(root.right);
102+
res = Math.max(res, left + right);
103+
return 1 + Math.max(left, right);
104+
}
105+
}
106+
```
107+
108+
### **C++**
109+
110+
```cpp
111+
/**
112+
* Definition for a binary tree node.
113+
* struct TreeNode {
114+
* int val;
115+
* TreeNode *left;
116+
* TreeNode *right;
117+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
118+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
119+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
120+
* };
121+
*/
122+
class Solution {
123+
public:
124+
int res;
125+
126+
int diameterOfBinaryTree(TreeNode* root) {
127+
res = 0;
128+
dfs(root);
129+
return res;
130+
}
131+
132+
int dfs(TreeNode* root) {
133+
if (!root) return 0;
134+
int left = dfs(root->left), right = dfs(root->right);
135+
res = max(res, left + right);
136+
return 1 + max(left, right);
137+
}
138+
};
139+
```
51140
141+
### **Go**
142+
143+
```go
144+
/**
145+
* Definition for a binary tree node.
146+
* type TreeNode struct {
147+
* Val int
148+
* Left *TreeNode
149+
* Right *TreeNode
150+
* }
151+
*/
152+
var res int
153+
154+
func diameterOfBinaryTree(root *TreeNode) int {
155+
res = 0
156+
dfs(root)
157+
return res
158+
}
159+
160+
func dfs(root *TreeNode) int {
161+
if root == nil {
162+
return 0
163+
}
164+
left, right := dfs(root.Left), dfs(root.Right)
165+
res = max(res, left+right)
166+
return 1 + max(left, right)
167+
}
168+
169+
func max(a, b int) int {
170+
if a > b {
171+
return a
172+
}
173+
return b
174+
}
52175
```
53176

54177
### **...**
Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
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+
int res;
15+
16+
int diameterOfBinaryTree(TreeNode* root) {
17+
res = 0;
18+
dfs(root);
19+
return res;
20+
}
21+
22+
int dfs(TreeNode* root) {
23+
if (!root) return 0;
24+
int left = dfs(root->left), right = dfs(root->right);
25+
res = max(res, left + right);
26+
return 1 + max(left, right);
27+
}
28+
};
Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* type TreeNode struct {
4+
* Val int
5+
* Left *TreeNode
6+
* Right *TreeNode
7+
* }
8+
*/
9+
var res int
10+
11+
func diameterOfBinaryTree(root *TreeNode) int {
12+
res = 0
13+
dfs(root)
14+
return res
15+
}
16+
17+
func dfs(root *TreeNode) int {
18+
if root == nil {
19+
return 0
20+
}
21+
left, right := dfs(root.Left), dfs(root.Right)
22+
res = max(res, left+right)
23+
return 1 + max(left, right)
24+
}
25+
26+
func max(a, b int) int {
27+
if a > b {
28+
return a
29+
}
30+
return b
31+
}

‎solution/0500-0599/0543.Diameter of Binary Tree/Solution.java‎

Lines changed: 19 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -4,22 +4,31 @@
44
* int val;
55
* TreeNode left;
66
* TreeNode right;
7-
* TreeNode(int x) { val = x; }
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+
* }
814
* }
915
*/
1016
class Solution {
11-
int ans = 1;
17+
privateint res;
1218

1319
public int diameterOfBinaryTree(TreeNode root) {
14-
depth(root);
15-
return ans - 1;
20+
res = 0;
21+
dfs(root);
22+
return res;
1623
}
1724

18-
public int depth(TreeNode node) {
19-
if (node == null) return 0;
20-
int L = depth(node.left);
21-
int R = depth(node.right);
22-
ans = Math.max(ans, L + R + 1);
23-
return Math.max(L, R) + 1;
25+
private int dfs(TreeNode root) {
26+
if (root == null) {
27+
return 0;
28+
}
29+
int left = dfs(root.left);
30+
int right = dfs(root.right);
31+
res = Math.max(res, left + right);
32+
return 1 + Math.max(left, right);
2433
}
2534
}

0 commit comments

Comments
(0)

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