feat: solve No.1609

Author: BaffinLee

1601-1700/1609. Even Odd Tree.md

@@ -0,0 +1,118 @@
+# 1609. Even Odd Tree
+
+- Difficulty: Medium.
+- Related Topics: Tree, Breadth-First Search, Binary Tree.
+- Similar Questions: .
+
+## Problem
+
+A binary tree is named **Even-Odd** if it meets the following conditions:
+
+
+	
+- The root of the binary tree is at level index `0`, its children are at level index `1`, their children are at level index `2`, etc.
+	
+- For every **even-indexed** level, all nodes at the level have **odd** integer values in **strictly increasing** order (from left to right).
+	
+- For every **odd-indexed** level, all nodes at the level have **even** integer values in **strictly decreasing** order (from left to right).
+
+
+Given the `root` of a binary tree, **return **`true`** if the binary tree is **Even-Odd**, otherwise return **`false`**.**
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2020/09/15/sample_1_1966.png)
+
+```
+Input: root = [1,10,4,3,null,7,9,12,8,6,null,null,2]
+Output: true
+Explanation: The node values on each level are:
+Level 0: [1]
+Level 1: [10,4]
+Level 2: [3,7,9]
+Level 3: [12,8,6,2]
+Since levels 0 and 2 are all odd and increasing and levels 1 and 3 are all even and decreasing, the tree is Even-Odd.
+```
+
+Example 2:
+
+![](https://assets.leetcode.com/uploads/2020/09/15/sample_2_1966.png)
+
+```
+Input: root = [5,4,2,3,3,7]
+Output: false
+Explanation: The node values on each level are:
+Level 0: [5]
+Level 1: [4,2]
+Level 2: [3,3,7]
+Node values in level 2 must be in strictly increasing order, so the tree is not Even-Odd.
+```
+
+Example 3:
+
+![](https://assets.leetcode.com/uploads/2020/09/22/sample_1_333_1966.png)
+
+```
+Input: root = [5,9,1,3,5,7]
+Output: false
+Explanation: Node values in the level 1 should be even integers.
+```
+
+ 
+**Constraints:**
+
+
+	
+- The number of nodes in the tree is in the range `[1, 105]`.
+	
+- `1 <= Node.val <= 106`
+
+
+
+## Solution
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+var isEvenOddTree = function(root) {
+    var nodesOfLevel = [root];
+    var level = 0;
+    while (nodesOfLevel.length) {
+        var newNodesOfLevel = [];
+        for (var i = 0; i < nodesOfLevel.length; i++) {
+            if (level % 2) {
+                if (nodesOfLevel[i].val % 2) return false;
+                if (i > 0 && nodesOfLevel[i].val >= nodesOfLevel[i - 1].val) return false;
+            } else {
+                if (nodesOfLevel[i].val % 2 === 0) return false;
+                if (i > 0 && nodesOfLevel[i].val <= nodesOfLevel[i - 1].val) return false;
+            }
+            nodesOfLevel[i].left && newNodesOfLevel.push(nodesOfLevel[i].left);
+            nodesOfLevel[i].right && newNodesOfLevel.push(nodesOfLevel[i].right);
+        }
+        nodesOfLevel = newNodesOfLevel;
+        level += 1;
+    }
+    return true;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).