Skip to content

Commit cd81da7

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0863
No.0863.All Nodes Distance K in Binary Tree
1 parent 62e9cf1 commit cd81da7

File tree

6 files changed

+503
-2
lines changed

6 files changed

+503
-2
lines changed

‎solution/0800-0899/0863.All Nodes Distance K in Binary Tree/README.md

+172-1
Original file line numberDiff line numberDiff line change
@@ -44,22 +44,193 @@
4444

4545
<!-- 这里可写通用的实现逻辑 -->
4646

47+
先用哈希表存放每个节点的父节点，然后 DFS 找到距离目标节点 target 为 k 的节点即可。
48+
4749
<!-- tabs:start -->
4850

4951
### **Python3**
5052

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

5355
```python
54-
56+
# Definition for a binary tree node.
57+
# class TreeNode:
58+
# def __init__(self, x):
59+
# self.val = x
60+
# self.left = None
61+
# self.right = None
62+
63+
class Solution:
64+
def distanceK(self, root: TreeNode, target: TreeNode, k: int) -> List[int]:
65+
def parents(root, prev):
66+
nonlocal p
67+
if root is None:
68+
return
69+
p[root] = prev
70+
parents(root.left, root)
71+
parents(root.right, root)
72+
73+
def dfs(root, k):
74+
nonlocal ans, vis
75+
if root is None or root.val in vis:
76+
return
77+
vis.add(root.val)
78+
if k == 0:
79+
ans.append(root.val)
80+
return
81+
dfs(root.left, k - 1)
82+
dfs(root.right, k - 1)
83+
dfs(p[root], k - 1)
84+
85+
p = {}
86+
parents(root, None)
87+
ans = []
88+
vis = set()
89+
dfs(target, k)
90+
return ans
5591
```
5692

5793
### **Java**
5894

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

6197
```java
98+
/**
99+
* Definition for a binary tree node.
100+
* public class TreeNode {
101+
* int val;
102+
* TreeNode left;
103+
* TreeNode right;
104+
* TreeNode(int x) { val = x; }
105+
* }
106+
*/
107+
class Solution {
108+
private Map<TreeNode, TreeNode> p;
109+
private Set<Integer> vis;
110+
private List<Integer> ans;
111+
112+
public List<Integer> distanceK(TreeNode root, TreeNode target, int k) {
113+
p = new HashMap<>();
114+
vis = new HashSet<>();
115+
ans = new ArrayList<>();
116+
parents(root, null);
117+
dfs(target, k);
118+
return ans;
119+
}
120+
121+
private void parents(TreeNode root, TreeNode prev) {
122+
if (root == null) {
123+
return;
124+
}
125+
p.put(root, prev);
126+
parents(root.left, root);
127+
parents(root.right, root);
128+
}
129+
130+
private void dfs(TreeNode root, int k) {
131+
if (root == null || vis.contains(root.val)) {
132+
return;
133+
}
134+
vis.add(root.val);
135+
if (k == 0) {
136+
ans.add(root.val);
137+
return;
138+
}
139+
dfs(root.left, k - 1);
140+
dfs(root.right, k - 1);
141+
dfs(p.get(root), k - 1);
142+
}
143+
}
144+
```
145+
146+
### **C++**
147+
148+
```cpp
149+
/**
150+
* Definition for a binary tree node.
151+
* struct TreeNode {
152+
* int val;
153+
* TreeNode *left;
154+
* TreeNode *right;
155+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
156+
* };
157+
*/
158+
class Solution {
159+
public:
160+
unordered_map<TreeNode*, TreeNode*> p;
161+
unordered_set<int> vis;
162+
vector<int> ans;
163+
164+
vector<int> distanceK(TreeNode* root, TreeNode* target, int k) {
165+
parents(root, nullptr);
166+
dfs(target, k);
167+
return ans;
168+
}
169+
170+
void parents(TreeNode* root, TreeNode* prev) {
171+
if (!root) return;
172+
p[root] = prev;
173+
parents(root->left, root);
174+
parents(root->right, root);
175+
}
176+
177+
void dfs(TreeNode* root, int k) {
178+
if (!root || vis.count(root->val)) return;
179+
vis.insert(root->val);
180+
if (k == 0)
181+
{
182+
ans.push_back(root->val);
183+
return;
184+
}
185+
dfs(root->left, k - 1);
186+
dfs(root->right, k - 1);
187+
dfs(p[root], k - 1);
188+
}
189+
};
190+
```
62191
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 distanceK(root *TreeNode, target *TreeNode, k int) []int {
204+
p := make(map[*TreeNode]*TreeNode)
205+
vis := make(map[int]bool)
206+
var ans []int
207+
var parents func(root, prev *TreeNode)
208+
parents = func(root, prev *TreeNode) {
209+
if root == nil {
210+
return
211+
}
212+
p[root] = prev
213+
parents(root.Left, root)
214+
parents(root.Right, root)
215+
}
216+
parents(root, nil)
217+
var dfs func(root *TreeNode, k int)
218+
dfs = func(root *TreeNode, k int) {
219+
if root == nil || vis[root.Val] {
220+
return
221+
}
222+
vis[root.Val] = true
223+
if k == 0 {
224+
ans = append(ans, root.Val)
225+
return
226+
}
227+
dfs(root.Left, k-1)
228+
dfs(root.Right, k-1)
229+
dfs(p[root], k-1)
230+
}
231+
dfs(target, k)
232+
return ans
233+
}
63234
```
64235

65236
### **...**

‎solution/0800-0899/0863.All Nodes Distance K in Binary Tree/README_EN.md

+170-1
Original file line numberDiff line numberDiff line change
@@ -66,13 +66,182 @@ The descriptions of the inputs above are just serializations of these objects.
6666
### **Python3**
6767

6868
```python
69-
69+
# Definition for a binary tree node.
70+
# class TreeNode:
71+
# def __init__(self, x):
72+
# self.val = x
73+
# self.left = None
74+
# self.right = None
75+
76+
class Solution:
77+
def distanceK(self, root: TreeNode, target: TreeNode, k: int) -> List[int]:
78+
def parents(root, prev):
79+
nonlocal p
80+
if root is None:
81+
return
82+
p[root] = prev
83+
parents(root.left, root)
84+
parents(root.right, root)
85+
86+
def dfs(root, k):
87+
nonlocal ans, vis
88+
if root is None or root.val in vis:
89+
return
90+
vis.add(root.val)
91+
if k == 0:
92+
ans.append(root.val)
93+
return
94+
dfs(root.left, k - 1)
95+
dfs(root.right, k - 1)
96+
dfs(p[root], k - 1)
97+
98+
p = {}
99+
parents(root, None)
100+
ans = []
101+
vis = set()
102+
dfs(target, k)
103+
return ans
70104
```
71105

72106
### **Java**
73107

74108
```java
109+
/**
110+
* Definition for a binary tree node.
111+
* public class TreeNode {
112+
* int val;
113+
* TreeNode left;
114+
* TreeNode right;
115+
* TreeNode(int x) { val = x; }
116+
* }
117+
*/
118+
class Solution {
119+
private Map<TreeNode, TreeNode> p;
120+
private Set<Integer> vis;
121+
private List<Integer> ans;
122+
123+
public List<Integer> distanceK(TreeNode root, TreeNode target, int k) {
124+
p = new HashMap<>();
125+
vis = new HashSet<>();
126+
ans = new ArrayList<>();
127+
parents(root, null);
128+
dfs(target, k);
129+
return ans;
130+
}
131+
132+
private void parents(TreeNode root, TreeNode prev) {
133+
if (root == null) {
134+
return;
135+
}
136+
p.put(root, prev);
137+
parents(root.left, root);
138+
parents(root.right, root);
139+
}
140+
141+
private void dfs(TreeNode root, int k) {
142+
if (root == null || vis.contains(root.val)) {
143+
return;
144+
}
145+
vis.add(root.val);
146+
if (k == 0) {
147+
ans.add(root.val);
148+
return;
149+
}
150+
dfs(root.left, k - 1);
151+
dfs(root.right, k - 1);
152+
dfs(p.get(root), k - 1);
153+
}
154+
}
155+
```
156+
157+
### **C++**
158+
159+
```cpp
160+
/**
161+
* Definition for a binary tree node.
162+
* struct TreeNode {
163+
* int val;
164+
* TreeNode *left;
165+
* TreeNode *right;
166+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
167+
* };
168+
*/
169+
class Solution {
170+
public:
171+
unordered_map<TreeNode*, TreeNode*> p;
172+
unordered_set<int> vis;
173+
vector<int> ans;
174+
175+
vector<int> distanceK(TreeNode* root, TreeNode* target, int k) {
176+
parents(root, nullptr);
177+
dfs(target, k);
178+
return ans;
179+
}
180+
181+
void parents(TreeNode* root, TreeNode* prev) {
182+
if (!root) return;
183+
p[root] = prev;
184+
parents(root->left, root);
185+
parents(root->right, root);
186+
}
187+
188+
void dfs(TreeNode* root, int k) {
189+
if (!root || vis.count(root->val)) return;
190+
vis.insert(root->val);
191+
if (k == 0)
192+
{
193+
ans.push_back(root->val);
194+
return;
195+
}
196+
dfs(root->left, k - 1);
197+
dfs(root->right, k - 1);
198+
dfs(p[root], k - 1);
199+
}
200+
};
201+
```
75202
203+
### **Go**
204+
205+
```go
206+
/**
207+
* Definition for a binary tree node.
208+
* type TreeNode struct {
209+
* Val int
210+
* Left *TreeNode
211+
* Right *TreeNode
212+
* }
213+
*/
214+
func distanceK(root *TreeNode, target *TreeNode, k int) []int {
215+
p := make(map[*TreeNode]*TreeNode)
216+
vis := make(map[int]bool)
217+
var ans []int
218+
var parents func(root, prev *TreeNode)
219+
parents = func(root, prev *TreeNode) {
220+
if root == nil {
221+
return
222+
}
223+
p[root] = prev
224+
parents(root.Left, root)
225+
parents(root.Right, root)
226+
}
227+
parents(root, nil)
228+
var dfs func(root *TreeNode, k int)
229+
dfs = func(root *TreeNode, k int) {
230+
if root == nil || vis[root.Val] {
231+
return
232+
}
233+
vis[root.Val] = true
234+
if k == 0 {
235+
ans = append(ans, root.Val)
236+
return
237+
}
238+
dfs(root.Left, k-1)
239+
dfs(root.Right, k-1)
240+
dfs(p[root], k-1)
241+
}
242+
dfs(target, k)
243+
return ans
244+
}
76245
```
77246

78247
### **...**

0 commit comments

Comments
 (0)