feat: ^_^

Signed-off-by: Luozhou (Siyuan Cao) <luozhou.csy@alibaba-inc.com>

Author: SR2k

102.二叉树的层序遍历.ts

@@ -0,0 +1,82 @@
+/*
+ * @lc app=leetcode.cn id=102 lang=typescript
+ *
+ * [102] 二叉树的层序遍历
+ *
+ * https://leetcode.cn/problems/binary-tree-level-order-traversal/description/
+ *
+ * algorithms
+ * Medium (65.02%)
+ * Likes:    1426
+ * Dislikes: 0
+ * Total Accepted:    648.8K
+ * Total Submissions: 997.8K
+ * Testcase Example:  '[3,9,20,null,null,15,7]'
+ *
+ * 给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：root = [3,9,20,null,null,15,7]
+ * 输出：[[3],[9,20],[15,7]]
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：root = [1]
+ * 输出：[[1]]
+ *
+ *
+ * 示例 3：
+ *
+ *
+ * 输入：root = []
+ * 输出：[]
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 树中节点数目在范围 [0, 2000] 内
+ * -1000 <= Node.val <= 1000
+ *
+ *
+ */
+
+import { TreeNode } from './commons/Tree'
+
+export
+// @lc code=start
+function levelOrder(root: TreeNode | null): number[][] {
+  const result: number[][] = []
+  const queue = [root].filter(Boolean)
+
+  while (queue.length) {
+    const levelLength = queue.length
+    const levelResult: number[] = []
+
+    for (let i = 0; i < levelLength; i++) {
+      const node = queue.shift()!
+
+      if (node.left) {
+        queue.push(node.left)
+      }
+      if (node.right) {
+        queue.push(node.right)
+      }
+
+      levelResult.push(node.val)
+    }
+
+    result.push(levelResult)
+  }
+
+  return result
+}
+// @lc code=end

103.二叉树的锯齿形层序遍历.ts

@@ -0,0 +1,84 @@
+/*
+ * @lc app=leetcode.cn id=103 lang=typescript
+ *
+ * [103] 二叉树的锯齿形层序遍历
+ *
+ * https://leetcode.cn/problems/binary-tree-zigzag-level-order-traversal/description/
+ *
+ * algorithms
+ * Medium (57.35%)
+ * Likes:    681
+ * Dislikes: 0
+ * Total Accepted:    259.7K
+ * Total Submissions: 452.8K
+ * Testcase Example:  '[3,9,20,null,null,15,7]'
+ *
+ * 给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：root = [3,9,20,null,null,15,7]
+ * 输出：[[3],[20,9],[15,7]]
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：root = [1]
+ * 输出：[[1]]
+ *
+ *
+ * 示例 3：
+ *
+ *
+ * 输入：root = []
+ * 输出：[]
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 树中节点数目在范围 [0, 2000] 内
+ * -100 <= Node.val <= 100
+ *
+ *
+ */
+
+import { TreeNode } from './commons/Tree'
+
+export
+// @lc code=start
+function zigzagLevelOrder(root: TreeNode | null): number[][] {
+  const queue = [root].filter(Boolean)
+  const result: number[][] = []
+
+  while (queue.length) {
+    const levelLength = queue.length
+    const levelResult: number[] = []
+
+    for (let i = 0; i < levelLength; i++) {
+      const node = queue.shift()!
+      levelResult.push(node.val)
+
+      if (node.left) {
+        queue.push(node.left)
+      }
+      if (node.right) {
+        queue.push(node.right)
+      }
+    }
+
+    if (result.length & 1) {
+      levelResult.reverse()
+    }
+    result.push(levelResult)
+  }
+
+  return result
+}
+// @lc code=end

116.填充每个节点的下一个右侧节点指针.ts

@@ -0,0 +1,94 @@
+/*
+ * @lc app=leetcode.cn id=116 lang=typescript
+ *
+ * [116] 填充每个节点的下一个右侧节点指针
+ *
+ * https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/description/
+ *
+ * algorithms
+ * Medium (71.92%)
+ * Likes:    850
+ * Dislikes: 0
+ * Total Accepted:    282.9K
+ * Total Submissions: 393.4K
+ * Testcase Example:  '[1,2,3,4,5,6,7]'
+ *
+ * 给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
+ *
+ *
+ * struct Node {
+ * ⁠ int val;
+ * ⁠ Node *left;
+ * ⁠ Node *right;
+ * ⁠ Node *next;
+ * }
+ *
+ * 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
+ *
+ * 初始状态下，所有 next 指针都被设置为 NULL。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ *
+ *
+ * 输入：root = [1,2,3,4,5,6,7]
+ * 输出：[1,#,2,3,#,4,5,6,7,#]
+ * 解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B
+ * 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。
+ *
+ *
+ *
+ *
+ * 示例 2:
+ *
+ *
+ * 输入：root = []
+ * 输出：[]
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 树中节点的数量在 [0, 2^12 - 1] 范围内
+ * -1000 <= node.val <= 1000
+ *
+ *
+ *
+ *
+ * 进阶：
+ *
+ *
+ * 你只能使用常量级额外空间。
+ * 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
+ *
+ *
+ */
+
+export
+// @lc code=start
+function connect(root: Node | null): Node | null {
+  let currLevel = root
+  while (currLevel?.left) {
+    let parent: Node | null = currLevel
+    let prevChild: Node | null = null
+    const nextLevel = currLevel.left
+
+    while (parent) {
+      if (prevChild) prevChild.next = parent.left
+      parent.left!.next = parent.right
+      prevChild = parent.right
+
+      parent = parent.next
+    }
+
+    currLevel = nextLevel
+  }
+
+  return root
+}
+// @lc code=end

117.填充每个节点的下一个右侧节点指针-ii.ts

@@ -0,0 +1,101 @@
+/*
+ * @lc app=leetcode.cn id=117 lang=typescript
+ *
+ * [117] 填充每个节点的下一个右侧节点指针 II
+ *
+ * https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/description/
+ *
+ * algorithms
+ * Medium (64.58%)
+ * Likes:    621
+ * Dislikes: 0
+ * Total Accepted:    150.6K
+ * Total Submissions: 233.2K
+ * Testcase Example:  '[1,2,3,4,5,null,7]'
+ *
+ * 给定一个二叉树
+ *
+ *
+ * struct Node {
+ * ⁠ int val;
+ * ⁠ Node *left;
+ * ⁠ Node *right;
+ * ⁠ Node *next;
+ * }
+ *
+ * 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
+ *
+ * 初始状态下，所有 next 指针都被设置为 NULL。
+ *
+ *
+ *
+ * 进阶：
+ *
+ *
+ * 你只能使用常量级额外空间。
+ * 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
+ *
+ *
+ *
+ *
+ * 示例：
+ *
+ *
+ *
+ *
+ * 输入：root = [1,2,3,4,5,null,7]
+ * 输出：[1,#,2,3,#,4,5,7,#]
+ * 解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next
+ * 指针连接），'#' 表示每层的末尾。
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 树中的节点数小于 6000
+ * -100
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+export
+// @lc code=start
+function connect(root: Node | null): Node | null {
+  let currLevelFirstNode = root
+
+  while (currLevelFirstNode) {
+    let curr: Node | null = currLevelFirstNode
+    let prevChild: Node | null = null
+    let nextLevelFirstNode: Node | null = null
+
+    while (curr) {
+      nextLevelFirstNode = nextLevelFirstNode || curr.left || curr.right
+      prevChild = connectTwo(prevChild, curr.left)
+      prevChild = connectTwo(prevChild, curr.right)
+
+      curr = curr.next
+    }
+
+    currLevelFirstNode = nextLevelFirstNode
+  }
+
+  return root
+}
+
+function connectTwo(prev: Node | null, curr: Node | null) {
+  if (!curr) {
+    return prev
+  }
+  if (!prev) {
+    return curr
+  }
+  prev.next = curr
+  return curr
+}
+// @lc code=end