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 1206b0b

Browse files
committed
feat: add solutions to lc problem: No.1609
No.1609.Even Odd Tree
1 parent d70fc7d commit 1206b0b

File tree

6 files changed

+451
-4
lines changed

6 files changed

+451
-4
lines changed

‎solution/1600-1699/1609.Even Odd Tree/README.md‎

Lines changed: 154 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -80,27 +80,179 @@
8080
<li><code>1 <= Node.val <= 10<sup>6</sup></code></li>
8181
</ul>
8282

83-
8483
## 解法
8584

8685
<!-- 这里可写通用的实现逻辑 -->
8786

87+
BFS。
88+
8889
<!-- tabs:start -->
8990

9091
### **Python3**
9192

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

9495
```python
95-
96+
# Definition for a binary tree node.
97+
# class TreeNode:
98+
# def __init__(self, val=0, left=None, right=None):
99+
# self.val = val
100+
# self.left = left
101+
# self.right = right
102+
class Solution:
103+
def isEvenOddTree(self, root: TreeNode) -> bool:
104+
even = True
105+
q = collections.deque([root])
106+
while q:
107+
n = len(q)
108+
prev = 0 if even else 10 ** 6
109+
for _ in range(n):
110+
node = q.popleft()
111+
if even and (prev >= node.val or node.val % 2 == 0):
112+
return False
113+
if not even and (prev <= node.val or node.val % 2 == 1):
114+
return False
115+
prev = node.val
116+
if node.left:
117+
q.append(node.left)
118+
if node.right:
119+
q.append(node.right)
120+
even = not even
121+
return True
96122
```
97123

98124
### **Java**
99125

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

102128
```java
129+
/**
130+
* Definition for a binary tree node.
131+
* public class TreeNode {
132+
* int val;
133+
* TreeNode left;
134+
* TreeNode right;
135+
* TreeNode() {}
136+
* TreeNode(int val) { this.val = val; }
137+
* TreeNode(int val, TreeNode left, TreeNode right) {
138+
* this.val = val;
139+
* this.left = left;
140+
* this.right = right;
141+
* }
142+
* }
143+
*/
144+
class Solution {
145+
public boolean isEvenOddTree(TreeNode root) {
146+
boolean even = true;
147+
Deque<TreeNode> q = new ArrayDeque<>();
148+
q.offerLast(root);
149+
while (!q.isEmpty()) {
150+
int prev = even ? 0 : 1000000;
151+
for (int i = 0, n = q.size(); i < n; ++i) {
152+
TreeNode node = q.pollFirst();
153+
if (even && (prev >= node.val || node.val % 2 == 0)) {
154+
return false;
155+
}
156+
if (!even && (prev <= node.val || node.val % 2 == 1)) {
157+
return false;
158+
}
159+
prev = node.val;
160+
if (node.left != null) {
161+
q.offerLast(node.left);
162+
}
163+
if (node.right != null) {
164+
q.offerLast(node.right);
165+
}
166+
}
167+
even = !even;
168+
}
169+
return true;
170+
}
171+
}
172+
```
173+
174+
### **C++**
175+
176+
```cpp
177+
/**
178+
* Definition for a binary tree node.
179+
* struct TreeNode {
180+
* int val;
181+
* TreeNode *left;
182+
* TreeNode *right;
183+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
184+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
185+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
186+
* };
187+
*/
188+
class Solution {
189+
public:
190+
bool isEvenOddTree(TreeNode* root) {
191+
bool even = true;
192+
queue<TreeNode*> q;
193+
q.push(root);
194+
while (!q.empty())
195+
{
196+
int prev = even ? 0 : 1000000;
197+
for (int i = 0, n = q.size(); i < n; ++i)
198+
{
199+
auto node = q.front();
200+
q.pop();
201+
if (even && (prev >= node->val || node->val % 2 == 0)) return false;
202+
if (!even && (prev <= node->val || node->val % 2 == 1)) return false;
203+
prev = node->val;
204+
if (node->left) q.push(node->left);
205+
if (node->right) q.push(node->right);
206+
}
207+
even = !even;
208+
}
209+
return true;
210+
}
211+
};
212+
```
103213
214+
### **Go**
215+
216+
```go
217+
/**
218+
* Definition for a binary tree node.
219+
* type TreeNode struct {
220+
* Val int
221+
* Left *TreeNode
222+
* Right *TreeNode
223+
* }
224+
*/
225+
func isEvenOddTree(root *TreeNode) bool {
226+
even := true
227+
var q []*TreeNode
228+
q = append(q, root)
229+
for len(q) > 0 {
230+
prev := 0
231+
if !even {
232+
prev = 1000000
233+
}
234+
n := len(q)
235+
for i := 0; i < n; i++ {
236+
node := q[0]
237+
q = q[1:]
238+
if even && (prev >= node.Val || node.Val%2 == 0) {
239+
return false
240+
}
241+
if !even && (prev <= node.Val || node.Val%2 == 1) {
242+
return false
243+
}
244+
prev = node.Val
245+
if node.Left != nil {
246+
q = append(q, node.Left)
247+
}
248+
if node.Right != nil {
249+
q = append(q, node.Right)
250+
}
251+
}
252+
even = !even
253+
}
254+
return true
255+
}
104256
```
105257

106258
### **...**

‎solution/1600-1699/1609.Even Odd Tree/README_EN.md‎

Lines changed: 154 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -76,21 +76,173 @@ Node values in the level 2 must be in strictly increasing order, so the tree is
7676
<li><code>1 &lt;= Node.val &lt;= 10<sup>6</sup></code></li>
7777
</ul>
7878

79-
8079
## Solutions
8180

81+
BFS.
82+
8283
<!-- tabs:start -->
8384

8485
### **Python3**
8586

8687
```python
87-
88+
# Definition for a binary tree node.
89+
# class TreeNode:
90+
# def __init__(self, val=0, left=None, right=None):
91+
# self.val = val
92+
# self.left = left
93+
# self.right = right
94+
class Solution:
95+
def isEvenOddTree(self, root: TreeNode) -> bool:
96+
even = True
97+
q = collections.deque([root])
98+
while q:
99+
n = len(q)
100+
prev = 0 if even else 10 ** 6
101+
for _ in range(n):
102+
node = q.popleft()
103+
if even and (prev >= node.val or node.val % 2 == 0):
104+
return False
105+
if not even and (prev <= node.val or node.val % 2 == 1):
106+
return False
107+
prev = node.val
108+
if node.left:
109+
q.append(node.left)
110+
if node.right:
111+
q.append(node.right)
112+
even = not even
113+
return True
88114
```
89115

90116
### **Java**
91117

92118
```java
119+
/**
120+
* Definition for a binary tree node.
121+
* public class TreeNode {
122+
* int val;
123+
* TreeNode left;
124+
* TreeNode right;
125+
* TreeNode() {}
126+
* TreeNode(int val) { this.val = val; }
127+
* TreeNode(int val, TreeNode left, TreeNode right) {
128+
* this.val = val;
129+
* this.left = left;
130+
* this.right = right;
131+
* }
132+
* }
133+
*/
134+
class Solution {
135+
public boolean isEvenOddTree(TreeNode root) {
136+
boolean even = true;
137+
Deque<TreeNode> q = new ArrayDeque<>();
138+
q.offerLast(root);
139+
while (!q.isEmpty()) {
140+
int prev = even ? 0 : 1000000;
141+
for (int i = 0, n = q.size(); i < n; ++i) {
142+
TreeNode node = q.pollFirst();
143+
if (even && (prev >= node.val || node.val % 2 == 0)) {
144+
return false;
145+
}
146+
if (!even && (prev <= node.val || node.val % 2 == 1)) {
147+
return false;
148+
}
149+
prev = node.val;
150+
if (node.left != null) {
151+
q.offerLast(node.left);
152+
}
153+
if (node.right != null) {
154+
q.offerLast(node.right);
155+
}
156+
}
157+
even = !even;
158+
}
159+
return true;
160+
}
161+
}
162+
```
163+
164+
### **C++**
165+
166+
```cpp
167+
/**
168+
* Definition for a binary tree node.
169+
* struct TreeNode {
170+
* int val;
171+
* TreeNode *left;
172+
* TreeNode *right;
173+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
174+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
175+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
176+
* };
177+
*/
178+
class Solution {
179+
public:
180+
bool isEvenOddTree(TreeNode* root) {
181+
bool even = true;
182+
queue<TreeNode*> q;
183+
q.push(root);
184+
while (!q.empty())
185+
{
186+
int prev = even ? 0 : 1000000;
187+
for (int i = 0, n = q.size(); i < n; ++i)
188+
{
189+
auto node = q.front();
190+
q.pop();
191+
if (even && (prev >= node->val || node->val % 2 == 0)) return false;
192+
if (!even && (prev <= node->val || node->val % 2 == 1)) return false;
193+
prev = node->val;
194+
if (node->left) q.push(node->left);
195+
if (node->right) q.push(node->right);
196+
}
197+
even = !even;
198+
}
199+
return true;
200+
}
201+
};
202+
```
93203
204+
### **Go**
205+
206+
```go
207+
/**
208+
* Definition for a binary tree node.
209+
* type TreeNode struct {
210+
* Val int
211+
* Left *TreeNode
212+
* Right *TreeNode
213+
* }
214+
*/
215+
func isEvenOddTree(root *TreeNode) bool {
216+
even := true
217+
var q []*TreeNode
218+
q = append(q, root)
219+
for len(q) > 0 {
220+
prev := 0
221+
if !even {
222+
prev = 1000000
223+
}
224+
n := len(q)
225+
for i := 0; i < n; i++ {
226+
node := q[0]
227+
q = q[1:]
228+
if even && (prev >= node.Val || node.Val%2 == 0) {
229+
return false
230+
}
231+
if !even && (prev <= node.Val || node.Val%2 == 1) {
232+
return false
233+
}
234+
prev = node.Val
235+
if node.Left != nil {
236+
q = append(q, node.Left)
237+
}
238+
if node.Right != nil {
239+
q = append(q, node.Right)
240+
}
241+
}
242+
even = !even
243+
}
244+
return true
245+
}
94246
```
95247

96248
### **...**
Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
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+
bool isEvenOddTree(TreeNode* root) {
15+
bool even = true;
16+
queue<TreeNode*> q;
17+
q.push(root);
18+
while (!q.empty())
19+
{
20+
int prev = even ? 0 : 1000000;
21+
for (int i = 0, n = q.size(); i < n; ++i)
22+
{
23+
auto node = q.front();
24+
q.pop();
25+
if (even && (prev >= node->val || node->val % 2 == 0)) return false;
26+
if (!even && (prev <= node->val || node->val % 2 == 1)) return false;
27+
prev = node->val;
28+
if (node->left) q.push(node->left);
29+
if (node->right) q.push(node->right);
30+
}
31+
even = !even;
32+
}
33+
return true;
34+
}
35+
};

0 commit comments

Comments
(0)

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