Skip to content

Commit 1206b0b

Browse files
yanglbmeyanglbme
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
### **...**

‎solution/1600-1699/1609.Even Odd Tree/Solution.cpp

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)