feat: ^_^

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

Author: SR2k

1.两数之和.ts

@@ -0,0 +1,79 @@
+/*
+ * @lc app=leetcode.cn id=1 lang=typescript
+ *
+ * [1] 两数之和
+ *
+ * https://leetcode.cn/problems/two-sum/description/
+ *
+ * algorithms
+ * Easy (52.77%)
+ * Likes:    15116
+ * Dislikes: 0
+ * Total Accepted:    3.7M
+ * Total Submissions: 7M
+ * Testcase Example:  '[2,7,11,15]\n9'
+ *
+ * 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
+ *
+ * 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
+ *
+ * 你可以按任意顺序返回答案。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：nums = [2,7,11,15], target = 9
+ * 输出：[0,1]
+ * 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
+ *
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：nums = [3,2,4], target = 6
+ * 输出：[1,2]
+ *
+ *
+ * 示例 3：
+ *
+ *
+ * 输入：nums = [3,3], target = 6
+ * 输出：[0,1]
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 2 <= nums.length <= 10^4
+ * -10^9 <= nums[i] <= 10^9
+ * -10^9 <= target <= 10^9
+ * 只会存在一个有效答案
+ *
+ *
+ * 进阶：你可以想出一个时间复杂度小于 O(n^2) 的算法吗？
+ *
+ */
+
+export
+// @lc code=start
+function twoSum(nums: number[], target: number): number[] {
+  const seen: Record<number, number> = {}
+
+  for (let i = 0; i < nums.length; i++) {
+    const n = nums[i]
+    const desired = target - n
+
+    if (typeof seen[desired] === 'number') {
+      return [seen[desired], i]
+    }
+
+    seen[n] = i
+  }
+
+  return [-1, -1]
+}
+// @lc code=end

138.复制带随机指针的链表.ts

@@ -0,0 +1,165 @@
+/*
+ * @lc app=leetcode.cn id=138 lang=typescript
+ *
+ * [138] 复制带随机指针的链表
+ *
+ * https://leetcode.cn/problems/copy-list-with-random-pointer/description/
+ *
+ * algorithms
+ * Medium (67.04%)
+ * Likes:    969
+ * Dislikes: 0
+ * Total Accepted:    165.5K
+ * Total Submissions: 246.9K
+ * Testcase Example:  '[[7,null],[13,0],[11,4],[10,2],[1,0]]'
+ *
+ * 给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。
+ *
+ * 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random
+ * 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。
+ *
+ * 例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random
+ * --> y 。
+ *
+ * 返回复制链表的头节点。
+ *
+ * 用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：
+ *
+ *
+ * val：一个表示 Node.val 的整数。
+ * random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为  null 。
+ *
+ *
+ * 你的代码 只 接受原链表的头节点 head 作为传入参数。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ *
+ *
+ * 输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
+ * 输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]
+ *
+ *
+ * 示例 2：
+ *
+ *
+ *
+ *
+ * 输入：head = [[1,1],[2,1]]
+ * 输出：[[1,1],[2,1]]
+ *
+ *
+ * 示例 3：
+ *
+ *
+ *
+ *
+ * 输入：head = [[3,null],[3,0],[3,null]]
+ * 输出：[[3,null],[3,0],[3,null]]
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 0 <= n <= 1000
+ * -10^4 <= Node.val <= 10^4
+ * Node.random 为 null 或指向链表中的节点。
+ *
+ *
+ */
+
+class Node {
+  val: number
+
+  next: Node | null
+
+  random: Node | null
+
+  constructor(val?: number, next?: Node, random?: Node) {
+    this.val = (val === undefined ? 0 : val)
+    this.next = (next === undefined ? null : next)
+    this.random = (random === undefined ? null : random)
+  }
+}
+
+export
+// @lc code=start
+function copyRandomList(head: Node | null): Node | null {
+  // copy all nodes to the next of original node
+  let curr = head
+  while (curr) {
+    const cloned = new Node(curr.val)
+    const { next } = curr
+
+    curr.next = cloned
+    cloned.next = next
+    curr = next
+  }
+
+  // point all random pointers
+  curr = head
+  while (curr) {
+    const { random, next: cloned } = curr
+    const next = cloned!.next
+
+    if (random) {
+      cloned!.random = random.next
+    }
+
+    curr = next
+  }
+
+  // split two list
+  const dummy = new Node()
+  let prevCloned = dummy
+  curr = head
+  while (curr) {
+    const { next: cloned } = curr
+    const next = cloned!.next
+
+    prevCloned.next = cloned!
+    prevCloned = prevCloned.next!
+    prevCloned.next = null
+
+    curr.next = next
+    curr = next
+  }
+
+  return dummy.next
+}
+// @lc code=end
+
+function getClonedOrCreate(map: Map<Node, Node>, original: Node | null) {
+  if (!original) return null
+
+  const cloned = map.get(original) || new Node(original.val)
+  map.set(original, cloned)
+  return cloned
+}
+
+function copyRandomList2(head: Node | null): Node | null {
+  const map = new Map<Node, Node>()
+  const dummy = new Node()
+  let curr = head
+  let prev = dummy
+
+  while (curr) {
+    const { random, next } = curr
+
+    const cloned = getClonedOrCreate(map, curr)!
+    cloned.random = getClonedOrCreate(map, random)
+    cloned.next = getClonedOrCreate(map, next)
+
+    prev.next = cloned
+    prev = prev.next
+
+    curr = curr.next
+  }
+
+  return dummy.next
+}

1448.统计二叉树中好节点的数目.ts

@@ -0,0 +1,78 @@
+/*
+ * @lc app=leetcode.cn id=1448 lang=typescript
+ *
+ * [1448] 统计二叉树中好节点的数目
+ *
+ * https://leetcode.cn/problems/count-good-nodes-in-binary-tree/description/
+ *
+ * algorithms
+ * Medium (72.16%)
+ * Likes:    59
+ * Dislikes: 0
+ * Total Accepted:    15.6K
+ * Total Submissions: 21.6K
+ * Testcase Example:  '[3,1,4,3,null,1,5]'
+ *
+ * 给你一棵根为 root 的二叉树，请你返回二叉树中好节点的数目。
+ *
+ * 「好节点」X 定义为：从根到该节点 X 所经过的节点中，没有任何节点的值大于 X 的值。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ *
+ * 输入：root = [3,1,4,3,null,1,5]
+ * 输出：4
+ * 解释：图中蓝色节点为好节点。
+ * 根节点 (3) 永远是个好节点。
+ * 节点 4 -> (3,4) 是路径中的最大值。
+ * 节点 5 -> (3,4,5) 是路径中的最大值。
+ * 节点 3 -> (3,1,3) 是路径中的最大值。
+ *
+ * 示例 2：
+ *
+ *
+ *
+ * 输入：root = [3,3,null,4,2]
+ * 输出：3
+ * 解释：节点 2 -> (3, 3, 2) 不是好节点，因为 "3" 比它大。
+ *
+ * 示例 3：
+ *
+ * 输入：root = [1]
+ * 输出：1
+ * 解释：根节点是好节点。
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 二叉树中节点数目范围是 [1, 10^5] 。
+ * 每个节点权值的范围是 [-10^4, 10^4] 。
+ *
+ *
+ */
+
+// @lc code=start
+function goodNodes(root: TreeNode | null): number {
+  let result = 0
+
+  const walk = (node: TreeNode | null, maxValue: number) => {
+    if (!node) return
+
+    if (maxValue <= node.val) {
+      result += 1
+    }
+
+    const nextMaxVal = Math.max(maxValue, node.val)
+    walk(node.left, nextMaxVal)
+    walk(node.right, nextMaxVal)
+  }
+
+  walk(root, Number.MIN_SAFE_INTEGER)
+  return result
+}
+// @lc code=end