Skip to content

Commit c93121b

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1740
No.1740.Find Distance in a Binary Tree
1 parent 680f6ca commit c93121b

File tree

6 files changed

+515
-2
lines changed

6 files changed

+515
-2
lines changed

‎solution/1700-1799/1740.Find Distance in a Binary Tree/README.md

Lines changed: 176 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -48,22 +48,197 @@
4848

4949
<!-- 这里可写通用的实现逻辑 -->
5050

51+
先找到两个整数节点的最近公共祖先 g。然后累加节点 g 到节点 p 和节点 q 的距离即可。
52+
5153
<!-- tabs:start -->
5254

5355
### **Python3**
5456

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

5759
```python
58-
60+
# Definition for a binary tree node.
61+
# class TreeNode:
62+
# def __init__(self, val=0, left=None, right=None):
63+
# self.val = val
64+
# self.left = left
65+
# self.right = right
66+
class Solution:
67+
def findDistance(self, root: Optional[TreeNode], p: int, q: int) -> int:
68+
def lca(root, p, q):
69+
if root is None or root.val in [p, q]:
70+
return root
71+
left = lca(root.left, p, q)
72+
right = lca(root.right, p, q)
73+
if left is None:
74+
return right
75+
if right is None:
76+
return left
77+
return root
78+
79+
def dfs(root, v):
80+
if root is None:
81+
return -1
82+
if root.val == v:
83+
return 0
84+
left, right = dfs(root.left, v), dfs(root.right, v)
85+
if left == right == -1:
86+
return -1
87+
return 1 + max(left, right)
88+
89+
g = lca(root, p, q)
90+
return dfs(g, p) + dfs(g, q)
5991
```
6092

6193
### **Java**
6294

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

6597
```java
98+
/**
99+
* Definition for a binary tree node.
100+
* public class TreeNode {
101+
* int val;
102+
* TreeNode left;
103+
* TreeNode right;
104+
* TreeNode() {}
105+
* TreeNode(int val) { this.val = val; }
106+
* TreeNode(int val, TreeNode left, TreeNode right) {
107+
* this.val = val;
108+
* this.left = left;
109+
* this.right = right;
110+
* }
111+
* }
112+
*/
113+
class Solution {
114+
public int findDistance(TreeNode root, int p, int q) {
115+
TreeNode g = lca(root, p, q);
116+
return dfs(g, p) + dfs(g, q);
117+
}
118+
119+
private int dfs(TreeNode root, int v) {
120+
if (root == null) {
121+
return -1;
122+
}
123+
if (root.val == v) {
124+
return 0;
125+
}
126+
int left = dfs(root.left, v);
127+
int right = dfs(root.right, v);
128+
if (left == -1 && right == -1) {
129+
return -1;
130+
}
131+
return 1 + Math.max(left, right);
132+
}
133+
134+
private TreeNode lca(TreeNode root, int p, int q) {
135+
if (root == null || root.val == p || root.val == q) {
136+
return root;
137+
}
138+
TreeNode left = lca(root.left, p, q);
139+
TreeNode right = lca(root.right, p, q);
140+
if (left == null) {
141+
return right;
142+
}
143+
if (right == null) {
144+
return left;
145+
}
146+
return root;
147+
}
148+
}
149+
```
150+
151+
### **C++**
152+
153+
```cpp
154+
/**
155+
* Definition for a binary tree node.
156+
* struct TreeNode {
157+
* int val;
158+
* TreeNode *left;
159+
* TreeNode *right;
160+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
161+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
162+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
163+
* };
164+
*/
165+
class Solution {
166+
public:
167+
int findDistance(TreeNode* root, int p, int q) {
168+
TreeNode* g = lca(root, p, q);
169+
return dfs(g, p) + dfs(g, q);
170+
}
171+
172+
TreeNode* lca(TreeNode* root, int p, int q) {
173+
if (!root || root->val == p || root->val == q) return root;
174+
TreeNode* left = lca(root->left, p, q);
175+
TreeNode* right = lca(root->right, p, q);
176+
if (!left) return right;
177+
if (!right) return left;
178+
return root;
179+
}
180+
181+
int dfs(TreeNode* root, int v) {
182+
if (!root) return -1;
183+
if (root->val == v) return 0;
184+
int left = dfs(root->left, v);
185+
int right = dfs(root->right, v);
186+
if (left == -1 && right == -1) return -1;
187+
return 1 + max(left, right);
188+
}
189+
};
190+
```
66191
192+
### **Go**
193+
194+
```go
195+
/**
196+
* Definition for a binary tree node.
197+
* type TreeNode struct {
198+
* Val int
199+
* Left *TreeNode
200+
* Right *TreeNode
201+
* }
202+
*/
203+
func findDistance(root *TreeNode, p int, q int) int {
204+
var lca func(root *TreeNode, p int, q int) *TreeNode
205+
lca = func(root *TreeNode, p int, q int) *TreeNode {
206+
if root == nil || root.Val == p || root.Val == q {
207+
return root
208+
}
209+
left, right := lca(root.Left, p, q), lca(root.Right, p, q)
210+
if left == nil {
211+
return right
212+
}
213+
if right == nil {
214+
return left
215+
}
216+
return root
217+
}
218+
var dfs func(root *TreeNode, v int) int
219+
dfs = func(root *TreeNode, v int) int {
220+
if root == nil {
221+
return -1
222+
}
223+
if root.Val == v {
224+
return 0
225+
}
226+
left, right := dfs(root.Left, v), dfs(root.Right, v)
227+
if left == -1 && right == -1 {
228+
return -1
229+
}
230+
return 1 + max(left, right)
231+
}
232+
g := lca(root, p, q)
233+
return dfs(g, p) + dfs(g, q)
234+
}
235+
236+
func max(a, b int) int {
237+
if a > b {
238+
return a
239+
}
240+
return b
241+
}
67242
```
68243

69244
### **...**

‎solution/1700-1799/1740.Find Distance in a Binary Tree/README_EN.md

Lines changed: 174 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -47,13 +47,186 @@
4747
### **Python3**
4848

4949
```python
50-
50+
# Definition for a binary tree node.
51+
# class TreeNode:
52+
# def __init__(self, val=0, left=None, right=None):
53+
# self.val = val
54+
# self.left = left
55+
# self.right = right
56+
class Solution:
57+
def findDistance(self, root: Optional[TreeNode], p: int, q: int) -> int:
58+
def lca(root, p, q):
59+
if root is None or root.val in [p, q]:
60+
return root
61+
left = lca(root.left, p, q)
62+
right = lca(root.right, p, q)
63+
if left is None:
64+
return right
65+
if right is None:
66+
return left
67+
return root
68+
69+
def dfs(root, v):
70+
if root is None:
71+
return -1
72+
if root.val == v:
73+
return 0
74+
left, right = dfs(root.left, v), dfs(root.right, v)
75+
if left == right == -1:
76+
return -1
77+
return 1 + max(left, right)
78+
79+
g = lca(root, p, q)
80+
return dfs(g, p) + dfs(g, q)
5181
```
5282

5383
### **Java**
5484

5585
```java
86+
/**
87+
* Definition for a binary tree node.
88+
* public class TreeNode {
89+
* int val;
90+
* TreeNode left;
91+
* TreeNode right;
92+
* TreeNode() {}
93+
* TreeNode(int val) { this.val = val; }
94+
* TreeNode(int val, TreeNode left, TreeNode right) {
95+
* this.val = val;
96+
* this.left = left;
97+
* this.right = right;
98+
* }
99+
* }
100+
*/
101+
class Solution {
102+
public int findDistance(TreeNode root, int p, int q) {
103+
TreeNode g = lca(root, p, q);
104+
return dfs(g, p) + dfs(g, q);
105+
}
106+
107+
private int dfs(TreeNode root, int v) {
108+
if (root == null) {
109+
return -1;
110+
}
111+
if (root.val == v) {
112+
return 0;
113+
}
114+
int left = dfs(root.left, v);
115+
int right = dfs(root.right, v);
116+
if (left == -1 && right == -1) {
117+
return -1;
118+
}
119+
return 1 + Math.max(left, right);
120+
}
121+
122+
private TreeNode lca(TreeNode root, int p, int q) {
123+
if (root == null || root.val == p || root.val == q) {
124+
return root;
125+
}
126+
TreeNode left = lca(root.left, p, q);
127+
TreeNode right = lca(root.right, p, q);
128+
if (left == null) {
129+
return right;
130+
}
131+
if (right == null) {
132+
return left;
133+
}
134+
return root;
135+
}
136+
}
137+
```
138+
139+
### **C++**
140+
141+
```cpp
142+
/**
143+
* Definition for a binary tree node.
144+
* struct TreeNode {
145+
* int val;
146+
* TreeNode *left;
147+
* TreeNode *right;
148+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
149+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
150+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
151+
* };
152+
*/
153+
class Solution {
154+
public:
155+
int findDistance(TreeNode* root, int p, int q) {
156+
TreeNode* g = lca(root, p, q);
157+
return dfs(g, p) + dfs(g, q);
158+
}
159+
160+
TreeNode* lca(TreeNode* root, int p, int q) {
161+
if (!root || root->val == p || root->val == q) return root;
162+
TreeNode* left = lca(root->left, p, q);
163+
TreeNode* right = lca(root->right, p, q);
164+
if (!left) return right;
165+
if (!right) return left;
166+
return root;
167+
}
168+
169+
int dfs(TreeNode* root, int v) {
170+
if (!root) return -1;
171+
if (root->val == v) return 0;
172+
int left = dfs(root->left, v);
173+
int right = dfs(root->right, v);
174+
if (left == -1 && right == -1) return -1;
175+
return 1 + max(left, right);
176+
}
177+
};
178+
```
56179
180+
### **Go**
181+
182+
```go
183+
/**
184+
* Definition for a binary tree node.
185+
* type TreeNode struct {
186+
* Val int
187+
* Left *TreeNode
188+
* Right *TreeNode
189+
* }
190+
*/
191+
func findDistance(root *TreeNode, p int, q int) int {
192+
var lca func(root *TreeNode, p int, q int) *TreeNode
193+
lca = func(root *TreeNode, p int, q int) *TreeNode {
194+
if root == nil || root.Val == p || root.Val == q {
195+
return root
196+
}
197+
left, right := lca(root.Left, p, q), lca(root.Right, p, q)
198+
if left == nil {
199+
return right
200+
}
201+
if right == nil {
202+
return left
203+
}
204+
return root
205+
}
206+
var dfs func(root *TreeNode, v int) int
207+
dfs = func(root *TreeNode, v int) int {
208+
if root == nil {
209+
return -1
210+
}
211+
if root.Val == v {
212+
return 0
213+
}
214+
left, right := dfs(root.Left, v), dfs(root.Right, v)
215+
if left == -1 && right == -1 {
216+
return -1
217+
}
218+
return 1 + max(left, right)
219+
}
220+
g := lca(root, p, q)
221+
return dfs(g, p) + dfs(g, q)
222+
}
223+
224+
func max(a, b int) int {
225+
if a > b {
226+
return a
227+
}
228+
return b
229+
}
57230
```
58231

59232
### **...**

0 commit comments

Comments
 (0)