https://leetcode.cn/problems/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/

Author: masx200

README.md

@@ -10,6 +10,8 @@ leetcode 测试
 
 ##### 包含的内容如下
 
+https://leetcode.cn/problems/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/
+
 https://leetcode.cn/problems/validate-binary-tree-nodes/
 
 https://leetcode.cn/problems/alert-using-same-key-card-three-or-more-times-in-a-one-hour-period/

alert-using-same-key-card-three-or-more-times-in-a-one-hour-period/index.ts

@@ -1,28 +1,28 @@
-export default function alertNames(
-    keyName: string[],
-    keyTime: string[]
-): string[] {
-    const map = new Map<string, number[]>();
-
-    for (const [i, n] of keyName.entries()) {
-        const t = keyTime[i]
-            .split(":")
-            .map(Number)
-            .reduce((p, c, i) => p + (i === 0 ? 60 * c : c), 0);
-
-        const arr = map.get(n) ?? [];
-        arr.push(t);
-        map.set(n, arr);
-    }
-
-    return [...map]
-        .filter(
-            ([_k, v]) =>
-                v.length >= 3 &&
-                v
-                    .sort((a, b) => a - b)
-                    .some((n, i, a) => i + 2 < a.length && 60 >= a[i + 2] - n)
-        )
-        .map((a) => a[0])
-        .sort();
-}
+export default function alertNames(
+    keyName: string[],
+    keyTime: string[],
+): string[] {
+    const map = new Map<string, number[]>();
+
+    for (const [i, n] of keyName.entries()) {
+        const t = keyTime[i]
+            .split(":")
+            .map(Number)
+            .reduce((p, c, i) => p + (i === 0 ? 60 * c : c), 0);
+
+        const arr = map.get(n) ?? [];
+        arr.push(t);
+        map.set(n, arr);
+    }
+
+    return [...map]
+        .filter(
+            ([_k, v]) =>
+                v.length >= 3 &&
+                v
+                    .sort((a, b) => a - b)
+                    .some((n, i, a) => i + 2 < a.length && 60 >= a[i + 2] - n),
+        )
+        .map((a) => a[0])
+        .sort();
+}

find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/index.ts

@@ -0,0 +1,19 @@
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
+
+export default function getTargetCopy(
+    original: TreeNode | null,
+    cloned: TreeNode | null,
+    target: TreeNode | null,
+): TreeNode | null {
+    if (!target || !cloned) return null;
+    if (target.val === cloned.val) return cloned;
+    if (cloned.right) {
+        const right = getTargetCopy(original, cloned.right, target);
+        if (right) return right;
+    }
+    if (cloned.left) {
+        const left = getTargetCopy(original, cloned.left, target);
+        if (left) return left;
+    }
+    return null;
+}

validate-binary-tree-nodes/index.ts

@@ -1,37 +1,38 @@
-export default function validateBinaryTreeNodes(
-    n: number,
-    leftChild: number[],
-    rightChild: number[]
-): boolean {
-    const degree = Array(n).fill(0);
-    for (const i of leftChild) {
-        if (i >= 0) degree[i]++;
-    }
-    for (const i of rightChild) {
-        if (i >= 0) degree[i]++;
-    }
-
-    const zeros = degree.filter((a) => a === 0);
-    if (
-        !(
-            Math.min(...degree) === 0 &&
-            (n === 1 || Math.max(...degree) === 1) &&
-            zeros.length === 1
-        )
-    )
-        return false;
-
-    const visited = new Set<number>();
-
-    const q = [degree.findIndex((a) => a === 0)];
-    for (const i of q) {
-        if (visited.has(i)) continue;
-
-        visited.add(i);
-        [leftChild[i], rightChild[i]]
-            .filter((a) => a >= 0)
-            .forEach((j) => q.push(j));
-    }
-
-    return visited.size === n;
-}
+export default function validateBinaryTreeNodes(
+    n: number,
+    leftChild: number[],
+    rightChild: number[],
+): boolean {
+    const degree = Array(n).fill(0);
+    for (const i of leftChild) {
+        if (i >= 0) degree[i]++;
+    }
+    for (const i of rightChild) {
+        if (i >= 0) degree[i]++;
+    }
+
+    const zeros = degree.filter((a) => a === 0);
+    if (
+        !(
+            Math.min(...degree) === 0 &&
+            (n === 1 || Math.max(...degree) === 1) &&
+            zeros.length === 1
+        )
+    ) {
+        return false;
+    }
+
+    const visited = new Set<number>();
+
+    const q = [degree.findIndex((a) => a === 0)];
+    for (const i of q) {
+        if (visited.has(i)) continue;
+
+        visited.add(i);
+        [leftChild[i], rightChild[i]]
+            .filter((a) => a >= 0)
+            .forEach((j) => q.push(j));
+    }
+
+    return visited.size === n;
+}