Skip to content

Commit 1dd9ff7

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1602.Find Nearest Right Node in Binary Tree
1 parent 93a3ab3 commit 1dd9ff7

File tree

6 files changed

+367
-4
lines changed

6 files changed

+367
-4
lines changed

‎solution/1600-1699/1602.Find Nearest Right Node in Binary Tree/README.md

+126-2
Original file line numberDiff line numberDiff line change
@@ -49,27 +49,151 @@
4949
<li><code>u</code> 是以 <code>root</code> 为根的二叉树的一个节点。</li>
5050
</ul>
5151

52-
5352
## 解法
5453

5554
<!-- 这里可写通用的实现逻辑 -->
5655

56+
BFS 层序遍历。
57+
5758
<!-- tabs:start -->
5859

5960
### **Python3**
6061

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

6364
```python
64-
65+
# Definition for a binary tree node.
66+
# class TreeNode:
67+
# def __init__(self, val=0, left=None, right=None):
68+
# self.val = val
69+
# self.left = left
70+
# self.right = right
71+
class Solution:
72+
def findNearestRightNode(self, root: TreeNode, u: TreeNode) -> TreeNode:
73+
q = collections.deque([root])
74+
while q:
75+
n = len(q)
76+
for i in range(n):
77+
node = q.popleft()
78+
if node == u:
79+
return None if i == n - 1 else q.popleft()
80+
if node.left:
81+
q.append(node.left)
82+
if node.right:
83+
q.append(node.right)
6584
```
6685

6786
### **Java**
6887

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

7190
```java
91+
/**
92+
* Definition for a binary tree node.
93+
* public class TreeNode {
94+
* int val;
95+
* TreeNode left;
96+
* TreeNode right;
97+
* TreeNode() {}
98+
* TreeNode(int val) { this.val = val; }
99+
* TreeNode(int val, TreeNode left, TreeNode right) {
100+
* this.val = val;
101+
* this.left = left;
102+
* this.right = right;
103+
* }
104+
* }
105+
*/
106+
class Solution {
107+
public TreeNode findNearestRightNode(TreeNode root, TreeNode u) {
108+
Deque<TreeNode> q = new ArrayDeque<>();
109+
q.offer(root);
110+
while (!q.isEmpty()) {
111+
for (int i = 0, n = q.size(); i < n; ++i) {
112+
TreeNode node = q.poll();
113+
if (node == u) {
114+
return i == n - 1 ? null : q.poll();
115+
}
116+
if (node.left != null) {
117+
q.offer(node.left);
118+
}
119+
if (node.right != null) {
120+
q.offer(node.right);
121+
}
122+
}
123+
}
124+
return null;
125+
}
126+
}
127+
```
128+
129+
### **C++**
130+
131+
```cpp
132+
/**
133+
* Definition for a binary tree node.
134+
* struct TreeNode {
135+
* int val;
136+
* TreeNode *left;
137+
* TreeNode *right;
138+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
139+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
140+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
141+
* };
142+
*/
143+
class Solution {
144+
public:
145+
TreeNode* findNearestRightNode(TreeNode* root, TreeNode* u) {
146+
queue<TreeNode*> q;
147+
q.push(root);
148+
while (!q.empty())
149+
{
150+
for (int i = 0, n = q.size(); i < n; ++i)
151+
{
152+
TreeNode* node = q.front();
153+
q.pop();
154+
if (node == u) return i == n - 1 ? nullptr : q.front();
155+
if (node->left) q.push(node->left);
156+
if (node->right) q.push(node->right);
157+
}
158+
}
159+
return nullptr;
160+
}
161+
};
162+
```
72163
164+
### **Go**
165+
166+
```go
167+
/**
168+
* Definition for a binary tree node.
169+
* type TreeNode struct {
170+
* Val int
171+
* Left *TreeNode
172+
* Right *TreeNode
173+
* }
174+
*/
175+
func findNearestRightNode(root *TreeNode, u *TreeNode) *TreeNode {
176+
q := []*TreeNode{root}
177+
for len(q) > 0 {
178+
t := q
179+
q = nil
180+
for i, node := range t {
181+
if node == u {
182+
if i == len(t)-1 {
183+
return nil
184+
}
185+
return t[i+1]
186+
}
187+
if node.Left != nil {
188+
q = append(q, node.Left)
189+
}
190+
if node.Right != nil {
191+
q = append(q, node.Right)
192+
}
193+
}
194+
}
195+
return nil
196+
}
73197
```
74198

75199
### **...**

‎solution/1600-1699/1602.Find Nearest Right Node in Binary Tree/README_EN.md

+126-2
Original file line numberDiff line numberDiff line change
@@ -51,21 +51,145 @@
5151
<li><code>u</code> is a node in the binary tree rooted at <code>root</code>.</li>
5252
</ul>
5353

54-
5554
## Solutions
5655

56+
BFS.
57+
5758
<!-- tabs:start -->
5859

5960
### **Python3**
6061

6162
```python
62-
63+
# Definition for a binary tree node.
64+
# class TreeNode:
65+
# def __init__(self, val=0, left=None, right=None):
66+
# self.val = val
67+
# self.left = left
68+
# self.right = right
69+
class Solution:
70+
def findNearestRightNode(self, root: TreeNode, u: TreeNode) -> TreeNode:
71+
q = collections.deque([root])
72+
while q:
73+
n = len(q)
74+
for i in range(n):
75+
node = q.popleft()
76+
if node == u:
77+
return None if i == n - 1 else q.popleft()
78+
if node.left:
79+
q.append(node.left)
80+
if node.right:
81+
q.append(node.right)
6382
```
6483

6584
### **Java**
6685

6786
```java
87+
/**
88+
* Definition for a binary tree node.
89+
* public class TreeNode {
90+
* int val;
91+
* TreeNode left;
92+
* TreeNode right;
93+
* TreeNode() {}
94+
* TreeNode(int val) { this.val = val; }
95+
* TreeNode(int val, TreeNode left, TreeNode right) {
96+
* this.val = val;
97+
* this.left = left;
98+
* this.right = right;
99+
* }
100+
* }
101+
*/
102+
class Solution {
103+
public TreeNode findNearestRightNode(TreeNode root, TreeNode u) {
104+
Deque<TreeNode> q = new ArrayDeque<>();
105+
q.offer(root);
106+
while (!q.isEmpty()) {
107+
for (int i = 0, n = q.size(); i < n; ++i) {
108+
TreeNode node = q.poll();
109+
if (node == u) {
110+
return i == n - 1 ? null : q.poll();
111+
}
112+
if (node.left != null) {
113+
q.offer(node.left);
114+
}
115+
if (node.right != null) {
116+
q.offer(node.right);
117+
}
118+
}
119+
}
120+
return null;
121+
}
122+
}
123+
```
124+
125+
### **C++**
126+
127+
```cpp
128+
/**
129+
* Definition for a binary tree node.
130+
* struct TreeNode {
131+
* int val;
132+
* TreeNode *left;
133+
* TreeNode *right;
134+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
135+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
136+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
137+
* };
138+
*/
139+
class Solution {
140+
public:
141+
TreeNode* findNearestRightNode(TreeNode* root, TreeNode* u) {
142+
queue<TreeNode*> q;
143+
q.push(root);
144+
while (!q.empty())
145+
{
146+
for (int i = 0, n = q.size(); i < n; ++i)
147+
{
148+
TreeNode* node = q.front();
149+
q.pop();
150+
if (node == u) return i == n - 1 ? nullptr : q.front();
151+
if (node->left) q.push(node->left);
152+
if (node->right) q.push(node->right);
153+
}
154+
}
155+
return nullptr;
156+
}
157+
};
158+
```
68159
160+
### **Go**
161+
162+
```go
163+
/**
164+
* Definition for a binary tree node.
165+
* type TreeNode struct {
166+
* Val int
167+
* Left *TreeNode
168+
* Right *TreeNode
169+
* }
170+
*/
171+
func findNearestRightNode(root *TreeNode, u *TreeNode) *TreeNode {
172+
q := []*TreeNode{root}
173+
for len(q) > 0 {
174+
t := q
175+
q = nil
176+
for i, node := range t {
177+
if node == u {
178+
if i == len(t)-1 {
179+
return nil
180+
}
181+
return t[i+1]
182+
}
183+
if node.Left != nil {
184+
q = append(q, node.Left)
185+
}
186+
if node.Right != nil {
187+
q = append(q, node.Right)
188+
}
189+
}
190+
}
191+
return nil
192+
}
69193
```
70194

71195
### **...**

‎solution/1600-1699/1602.Find Nearest Right Node in Binary Tree/Solution.cpp

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
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+
TreeNode* findNearestRightNode(TreeNode* root, TreeNode* u) {
15+
queue<TreeNode*> q;
16+
q.push(root);
17+
while (!q.empty())
18+
{
19+
for (int i = 0, n = q.size(); i < n; ++i)
20+
{
21+
TreeNode* node = q.front();
22+
q.pop();
23+
if (node == u) return i == n - 1 ? nullptr : q.front();
24+
if (node->left) q.push(node->left);
25+
if (node->right) q.push(node->right);
26+
}
27+
}
28+
return nullptr;
29+
}
30+
};

‎solution/1600-1699/1602.Find Nearest Right Node in Binary Tree/Solution.go

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* type TreeNode struct {
4+
* Val int
5+
* Left *TreeNode
6+
* Right *TreeNode
7+
* }
8+
*/
9+
func findNearestRightNode(root *TreeNode, u *TreeNode) *TreeNode {
10+
q := []*TreeNode{root}
11+
for len(q) > 0 {
12+
t := q
13+
q = nil
14+
for i, node := range t {
15+
if node == u {
16+
if i == len(t)-1 {
17+
return nil
18+
}
19+
return t[i+1]
20+
}
21+
if node.Left != nil {
22+
q = append(q, node.Left)
23+
}
24+
if node.Right != nil {
25+
q = append(q, node.Right)
26+
}
27+
}
28+
}
29+
return nil
30+
}

0 commit comments

Comments
 (0)