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 1dd9ff7

Browse files
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‎

Lines changed: 126 additions & 2 deletions
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‎

Lines changed: 126 additions & 2 deletions
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
### **...**
Lines changed: 30 additions & 0 deletions
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+
};
Lines changed: 30 additions & 0 deletions
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)

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