Add solution 1609

Author: halfrost

website/content/ChapterFour/1600~1699/1609.Even-Odd-Tree.md

@@ -0,0 +1,157 @@
+# [1609. Even Odd Tree](https://leetcode.com/problems/even-odd-tree/)
+
+## 题目
+
+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](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](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](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.
+
+**Example 4**:
+
+    Input: root = [1]
+    Output: true
+
+**Example 5**:
+
+    Input: root = [11,8,6,1,3,9,11,30,20,18,16,12,10,4,2,17]
+    Output: True
+
+**Constraints:**
+
+- The number of nodes in the tree is in the range [1, 100000]. 
+- 1 <= Node.val <= 1000000
+
+## 题目大意
+
+如果一棵二叉树满足下述几个条件，则可以称为 奇偶树 ：
+
+- 二叉树根节点所在层下标为 0 ，根的子节点所在层下标为 1 ，根的孙节点所在层下标为 2 ，依此类推。
+- 偶数下标 层上的所有节点的值都是 奇 整数，从左到右按顺序 严格递增
+- 奇数下标 层上的所有节点的值都是 偶 整数，从左到右按顺序 严格递减
+
+给你二叉树的根节点，如果二叉树为 奇偶树 ，则返回 true ，否则返回 false 。
+
+## 解题思路
+
+- 广度优先遍历(分别判断奇数层和偶数层)
+
+## 代码
+
+```go
+package leetcode
+
+type TreeNode struct {
+	Val int
+	Left *TreeNode
+	Right *TreeNode
+}
+
+func isEvenOddTree(root *TreeNode) bool {
+	level := 0
+	queue := []*TreeNode{root}
+	for len(queue) != 0 {
+		length := len(queue)
+		var nums []int
+		for i := 0; i < length; i++ {
+			node := queue[i]
+			if node.Left != nil {
+				queue = append(queue, node.Left)
+			}
+			if node.Right != nil {
+				queue = append(queue, node.Right)
+			}
+			nums = append(nums, node.Val)
+		}
+		if level%2 == 0 {
+			if !even(nums) {
+				return false
+			}
+		} else {
+			if !odd(nums) {
+				return false
+			}
+		}
+		queue = queue[length:]
+		level++
+	}
+	return true
+}
+
+func odd(nums []int) bool {
+	cur := nums[0]
+	if cur%2 != 0 {
+		return false
+	}
+	for _, num := range nums[1:] {
+		if num >= cur {
+			return false
+		}
+		if num%2 != 0 {
+			return false
+		}
+		cur = num
+	}
+	return true
+}
+
+func even(nums []int) bool {
+	cur := nums[0]
+	if cur%2 == 0 {
+		return false
+	}
+	for _, num := range nums[1:] {
+		if num <= cur {
+			return false
+		}
+		if num%2 == 0 {
+			return false
+		}
+		cur = num
+	}
+	return true
+}
+```
+
+
+----------------------------------------------
+<div style="display: flex;justify-content: space-between;align-items: center;">
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/1600~1699/1608.Special-Array-With-X-Elements-Greater-Than-or-Equal-X/">⬅️上一页</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/1600~1699/1614.Maximum-Nesting-Depth-of-the-Parentheses/">下一页➡️</a></p>
+</div>

website/content/ChapterFour/1600~1699/1614.Maximum-Nesting-Depth-of-the-Parentheses.md

@@ -104,6 +104,6 @@ func max(a, b int) int {
 
 ----------------------------------------------
 <div style="display: flex;justify-content: space-between;align-items: center;">
-<p><a href="https://books.halfrost.com/leetcode/ChapterFour/1600~1699/1608.Special-Array-With-X-Elements-Greater-Than-or-Equal-X/">⬅️上一页</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/1600~1699/1609.Even-Odd-Tree/">⬅️上一页</a></p>
 <p><a href="https://books.halfrost.com/leetcode/ChapterFour/1600~1699/1619.Mean-of-Array-After-Removing-Some-Elements/">下一页➡️</a></p>
 </div>

website/content/ChapterFour/1700~1799/1704.Determine-if-String-Halves-Are-Alike.md

@@ -78,5 +78,5 @@ func numVowels(x string) int {
 ----------------------------------------------
 <div style="display: flex;justify-content: space-between;align-items: center;">
 <p><a href="https://books.halfrost.com/leetcode/ChapterFour/1700~1799/1700.Number-of-Students-Unable-to-Eat-Lunch/">⬅️上一页</a></p>
-<p><a href="https://books.halfrost.com/leetcode/ChapterFour/1700~1799/1710.Maximum-Units-on-a-Truck/">下一页➡️</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/1700~1799/1705.Maximum-Number-of-Eaten-Apples/">下一页➡️</a></p>
 </div>