@@ -74,22 +74,214 @@ root = [1,2,3,4,null,null,null,5,null,6], k = 2
7474
7575<!-- 这里可写通用的实现逻辑 -->
7676
77+ DFS。
78+ 7779<!-- tabs:start -->
7880
7981### ** Python3**
8082
8183<!-- 这里可写当前语言的特殊实现逻辑 -->
8284
8385``` python
84- 86+ # Definition for a binary tree node.
87+ # class TreeNode:
88+ # def __init__(self, val=0, left=None, right=None):
89+ # self.val = val
90+ # self.left = left
91+ # self.right = right
92+ class Solution :
93+ def findClosestLeaf (self root : TreeNode, k : int ) -> int :
94+ def dfs (root , p ):
95+ if root:
96+ g[root].append(p)
97+ g[p].append(root)
98+ dfs(root.left, root)
99+ dfs(root.right, root)
100+ 101+ g = defaultdict(list )
102+ dfs(root, None )
103+ q = deque([node for node in g if node and node.val == k])
104+ seen = set ()
105+ while q:
106+ node = q.popleft()
107+ seen.add(node)
108+ if node:
109+ if node.left is None and node.right is None :
110+ return node.val
111+ for next in g[node]:
112+ if next not in seen:
113+ q.append(next )
85114```
86115
87116### ** Java**
88117
89118<!-- 这里可写当前语言的特殊实现逻辑 -->
90119
91120``` java
121+ /**
122+ * Definition for a binary tree node.
123+ * public class TreeNode {
124+ * int val;
125+ * TreeNode left;
126+ * TreeNode right;
127+ * TreeNode() {}
128+ * TreeNode(int val) { this.val = val; }
129+ * TreeNode(int val, TreeNode left, TreeNode right) {
130+ * this.val = val;
131+ * this.left = left;
132+ * this.right = right;
133+ * }
134+ * }
135+ */
136+ class Solution {
137+ private Map<TreeNode , List<TreeNode > > g;
138+ 139+ public int findClosestLeaf (TreeNode root , int k ) {
140+ g = new HashMap<> ();
141+ dfs(root, null );
142+ Deque<TreeNode > q = new LinkedList<> ();
143+ for (Map . Entry<TreeNode , List<TreeNode > > entry : g. entrySet()) {
144+ if (entry. getKey() != null && entry. getKey(). val == k) {
145+ q. offer(entry. getKey());
146+ break ;
147+ }
148+ }
149+ Set<TreeNode > seen = new HashSet<> ();
150+ while (! q. isEmpty()) {
151+ TreeNode node = q. poll();
152+ seen. add(node);
153+ if (node != null ) {
154+ if (node. left == null && node. right == null ) {
155+ return node. val;
156+ }
157+ for (TreeNode next : g. get(node)) {
158+ if (! seen. contains(next)) {
159+ q. offer(next);
160+ }
161+ }
162+ }
163+ }
164+ return 0 ;
165+ }
166+ 167+ private void dfs (TreeNode root , TreeNode p ) {
168+ if (root != null ) {
169+ g. computeIfAbsent(root, k - > new ArrayList<> ()). add(p);
170+ g. computeIfAbsent(p, k - > new ArrayList<> ()). add(root);
171+ dfs(root. left, root);
172+ dfs(root. right, root);
173+ }
174+ }
175+ }
176+ ```
177+ 178+ ### ** C++**
179+ 180+ ``` cpp
181+ /* *
182+ * Definition for a binary tree node.
183+ * struct TreeNode {
184+ * int val;
185+ * TreeNode *left;
186+ * TreeNode *right;
187+ * TreeNode() : val(0), left(nullptr), right(nullptr) {}
188+ * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
189+ * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
190+ * };
191+ */
192+ class Solution {
193+ public:
194+ unordered_map<TreeNode* , vector<TreeNode* >> g;
195+ 196+ int findClosestLeaf(TreeNode* root, int k) {
197+ dfs(root, nullptr);
198+ queue<TreeNode*> q;
199+ for (auto& e : g)
200+ {
201+ if (e.first && e.first->val == k)
202+ {
203+ q.push(e.first);
204+ break;
205+ }
206+ }
207+ unordered_set<TreeNode*> seen;
208+ while (!q.empty())
209+ {
210+ auto node = q.front();
211+ q.pop();
212+ seen.insert(node);
213+ if (node)
214+ {
215+ if (!node->left && !node->right) return node->val;
216+ for (auto next : g[node])
217+ {
218+ if (!seen.count(next))
219+ q.push(next);
220+ }
221+ }
222+ }
223+ return 0;
224+ }
225+ 226+ void dfs(TreeNode* root, TreeNode* p) {
227+ if (!root) return;
228+ g[root].push_back(p);
229+ g[p].push_back(root);
230+ dfs (root->left, root);
231+ dfs(root->right, root);
232+ }
233+ };
234+ ```
92235
236+ ### ** Go**
237+ 238+ ``` go
239+ /* *
240+ * Definition for a binary tree node.
241+ * type TreeNode struct {
242+ * Val int
243+ * Left *TreeNode
244+ * Right *TreeNode
245+ * }
246+ */
247+ func findClosestLeaf (root *TreeNode , k int ) int {
248+ g := make (map [*TreeNode][]*TreeNode)
249+ var dfs func (root, p *TreeNode)
250+ dfs = func (root, p *TreeNode) {
251+ if root == nil {
252+ return
253+ }
254+ g[root] = append (g[root], p)
255+ g[p] = append (g[p], root)
256+ dfs (root.Left , root)
257+ dfs (root.Right , root)
258+ }
259+ dfs (root, nil )
260+ var q []*TreeNode
261+ for t , _ := range g {
262+ if t != nil && t.Val == k {
263+ q = append (q, t)
264+ break
265+ }
266+ }
267+ seen := make (map [*TreeNode]bool )
268+ for len (q) > 0 {
269+ node := q[0 ]
270+ q = q[1 :]
271+ seen[node] = true
272+ if node != nil {
273+ if node.Left == nil && node.Right == nil {
274+ return node.Val
275+ }
276+ for _ , next := range g[node] {
277+ if !seen[next] {
278+ q = append (q, next)
279+ }
280+ }
281+ }
282+ }
283+ return 0
284+ }
93285```
94286
95287### ** ...**
0 commit comments