feat: update 5 leetcode about binary tree

Author: kyriejoshua

leetcode/222.count-complete-tree-nodes.ts

@@ -0,0 +1,34 @@
+/*
+ * @lc app=leetcode id=222 lang=typescript
+ *
+ * [222] Count Complete Tree Nodes
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ * val: number
+ * left: TreeNode | null
+ * right: TreeNode | null
+ * constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ * this.val = (val===undefined ? 0 : val)
+ * this.left = (left===undefined ? null : left)
+ * this.right = (right===undefined ? null : right)
+ * }
+ * }
+ */
+
+/**
+ * @description: 这里其实对常规二叉树也有效
+ * @param {TreeNode} root
+ * @return {number}
+ */
+function countNodes(root: TreeNode | null): number {
+ if (root === null) return 0;
+ const left = countNodes(root.left);
+ const right = countNodes(root.right);
+
+ return left + right + 1;
+};
+// @lc code=end

leetcode/230.kth-smallest-element-in-a-bst.ts

@@ -0,0 +1,79 @@
+/*
+ * @lc app=leetcode id=230 lang=typescript
+ *
+ * [230] Kth Smallest Element in a BST
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ * val: number
+ * left: TreeNode | null
+ * right: TreeNode | null
+ * constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ * this.val = (val===undefined ? 0 : val)
+ * this.left = (left===undefined ? null : left)
+ * this.right = (right===undefined ? null : right)
+ * }
+ * }
+ */
+
+/**
+ * @description: 中序遍历，迭代的方式
+ * 时间复杂度 O(H+k)
+ * 空间复杂度 O(H)
+ * H 是树的高度
+ * @param {TreeNode} root
+ * @param {number} k
+ * @return {number}
+ */
+function kthSmallest(root: TreeNode | null, k: number): number {
+ if (root === null) return null;
+
+ let stack = [root];
+ let node = root;
+ while (stack.length || node !== null) {
+ while (node !== null) {
+ stack.push(node);
+ node = node.left;
+ }
+ const cur = stack.pop();
+ k--;
+ if (k === 0) {
+ return cur.val;
+ }
+ if (cur.right !== null) {
+ node = cur.right;
+ }
+ }
+}
+
+/**
+ * @description: 二叉搜索树中序遍历后输出的值是有序的，利用这一特性
+ * 时间复杂度 O(n): 全部遍历一遍
+ * 空间复杂度 O(n)? 不确定
+ * @param {TreeNode} root
+ * @param {number} k
+ * @return {number}
+ */
+function kthSmallestByRecursion(root: TreeNode | null, k: number): number {
+ let res: number[] = [];
+
+ /**
+ * @description: 中序遍历，递归实现
+ * @param {TreeNode|null} node
+ * @return {void}
+ */
+ function inOrderWalker(node: TreeNode | null) {
+ if (node === null) return null;
+
+ inOrderWalker(node.left);
+ node.val !== null && res.push(node.val);
+ inOrderWalker(node.right);
+ }
+ inOrderWalker(root);
+
+ return res[k - 1];
+};
+// @lc code=end

leetcode/268.missing-number.ts

@@ -0,0 +1,95 @@
+/*
+ * @lc app=leetcode id=268 lang=typescript
+ *
+ * [268] Missing Number
+ */
+// @lc code=start
+/**
+ * @description: 位运算的思路
+ * 使用异或
+ * 时间复杂度 O(2n+1)
+ * 空间复杂度 O(1)
+ * @param {number} nums
+ * @return {number}
+ */
+function missingNumber(nums:number[]): number {
+ const n = nums.length;
+ let xor = 0;
+
+ for (let i = 0; i < n; i++) {
+ xor ^= nums[i]
+ }
+ // 注意这里的条件是小于等于，需要计算 n 的情况
+ for (let i = 0; i <= n; i++) {
+ xor ^= i;
+ }
+
+ return xor;
+}
+
+/**
+ * @description: 哈希表的思路
+ * 空间换时间
+ * 时间复杂度 O(2n)
+ * 空间复杂度 O(n)
+ * @param {number} nums
+ * @return {number}
+ */
+function missingNumber2(nums:number[]): number {
+ const arr: number[] = [];
+ const n = nums.length;
+
+ for (let i = 0; i < n; i++) {
+ // 使用另一个散列表数组来保存所有索引值
+ arr[nums[i]] = nums[i];
+ }
+
+ for (let i = 0; i < n; i++) {
+ // 如果没有，说明缺少这个数字
+ if (arr[i] === undefined) return i;
+ }
+
+ return n;
+}
+
+// 时间复杂度应该是 O(n^2)
+// 每次查询会耗费非常多的时间
+function missingNumber3(nums: number[]): number {
+ if (nums.length === 1) return nums[0] === 0 ? 1 : 0;
+
+ const n = nums.length;
+ // 直接使用连续索引来判断
+ for (let i = 0; i < n; i++) {
+ if (!nums.includes(i)) return i;
+ }
+
+ return n;
+};
+
+function missingNumber4(nums: number[]): number {
+ if (nums.length === 1) return nums[0] === 0 ? 1 : 0;
+
+ const n = nums.length;
+ nums.sort((a, b) => a - b);
+
+ // 利用排序后，每一位和对应的索引相等的特点
+ for (let i = 0; i < n; i++) {
+ if (nums[i] !== i) return i;
+ }
+
+ return n;
+};
+
+function missingNumber5(nums: number[]): number {
+ if (nums.length === 1) return nums[0] === 0 ? 1 : 0;
+
+ const n = nums.length;
+ nums.sort((a, b) => a - b);
+ // 利用排序后，后一位和前一位默认相差是 1 的特点来查询
+ for (let i = 1; i < n; i++) {
+ if (nums[i] !== nums[i - 1] + 1) return nums[i] - 1;
+ }
+
+ return nums[0] === 0 ? n : 0;
+};
+// @lc code=end

leetcode/701.insert-into-a-binary-search-tree.ts

@@ -0,0 +1,46 @@
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ * val: number
+ * left: TreeNode | null
+ * right: TreeNode | null
+ * constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ * this.val = (val===undefined ? 0 : val)
+ * this.left = (left===undefined ? null : left)
+ * this.right = (right===undefined ? null : right)
+ * }
+ * }
+ */
+
+/**
+ * @description: 循环的方式，不是递归的方式
+ * 时间复杂度 O(n)
+ * 空间复杂度 O(1)
+ * @param {TreeNode} root
+ * @param {number} val
+ * @return {TreeNode}
+ */
+function insertIntoBST(root: TreeNode | null, val: number): TreeNode | null {
+ if (root === null) return new TreeNode(val);
+ let node = root;
+
+ // 循环到尽头位置
+ while (node !== null) {
+ // 如果节点值比传入值小，就从右边开始找
+ if (node.val < val) {
+ if (node.right === null) {
+ node.right = new TreeNode(val);
+ break;
+ }
+ node = node.right;
+ } else {
+ if (node.left === null) {
+ node.left = new TreeNode(val);
+ break;
+ }
+ node = node.left;
+ }
+ }
+
+ return root;
+};

leetcode/96.unique-binary-search-trees.ts

@@ -0,0 +1,22 @@
+/*
+ * @lc app=leetcode id=96 lang=typescript
+ *
+ * [96] Unique Binary Search Trees
+ */
+
+// @lc code=start
+/**
+ * @description: 数学公式的方式，卡特兰数
+ * @param {number} n
+ * @return {number}
+ */
+function numTrees(n: number): number {
+ let C: number = 1;
+
+ for (let i = 0; i < n; i++) {
+ C *= 2 * (2 * i + 1) / (i + 2);
+ }
+
+ return C;
+};
+// @lc code=end