https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/

    1. /**
    2.  * Definition for a binary tree node.
    3.  * class TreeNode {
    4.  *     val: number
    5.  *     left: TreeNode | null
    6.  *     right: TreeNode | null
    7.  *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    8.  *         this.val = (val===undefined ? 0 : val)
    9.  *         this.left = (left===undefined ? null : left)
    10.  *         this.right = (right===undefined ? null : right)
    11.  *     }
    12.  * }
    13.  */
    15. function maxDepth(root: TreeNode | null): number {
    16.   if (!root) return null;
    17.   const left = maxDepth(root.left);
    18.   const right = maxDepth(root.right);
    19.   return 1 + Math.max(left, right);
    20. };

    https://bigfrontend.dev/zh/problem/immerjs

    1. type ProduceFunc = <T>(base: T, receipe: (draft: T) => any) => void
    3. const produce: ProduceFunc = (base, recipe) => {
    4.   const copy = deepCopy(base);
    5.   recipe(copy);
    6.   if (compare(base, copy)) {
    7.     return base
    8.   }
    9.   return copy
    10. }
    12. function deepCopy(obj: any) {
    13.   let output: any = Array.isArray(obj) ? [] : {};
    14.   if (obj === null || typeof obj !== 'object') {
    15.     return obj;
    16.   }
    18.   for (let key in obj) {
    19.     output[key] = deepCopy(obj[key])
    20.   }
    21.   return output;
    22. }
    24. function compare(origin: any, modified: any) {
    25.   if (typeof origin !== typeof modified) return false
    27.   if (typeof origin !== 'object') {
    28.     return origin === modified;
    29.   }
    31.   let isEqual = true
    33.   for (let key in origin) {
    34.     if (compare(origin[key], modified[key])) {
    35.       modified[key] = origin[key]
    36.     } else {
    37.       isEqual = false
    38.     }
    39.   }
    41.   return Object.keys(origin).length === Object.keys(modified).length && isEqual
    42. }