测试

Author: masx200

construct-binary-tree-from-preorder-and-inorder-traversal/index.ts

@@ -1,13 +1,27 @@
 import { TreeNode } from "../mod.ts";
 
 function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
-    if (preorder.length === 0) return null;
-    const i = inorder.findIndex((x) => x === preorder[0]);
-
-    return new TreeNode(
-        preorder[0],
-        buildTree(preorder.slice(1, i + 1), inorder.slice(0, i)),
-        buildTree(preorder.slice(i + 1), inorder.slice(i + 1)),
-    );
+    const map = new Map<number, number>();
+    for (let i = 0; i < inorder.length; i++) {
+        map.set(inorder[i], i);
+    }
+    function helper(
+        pStart: number,
+        pEnd: number,
+        iStart: number,
+        iEnd: number,
+    ): TreeNode | null {
+        if (pStart > pEnd) {
+            return null;
+        }
+        const rootVal = preorder[pStart];
+        const root = new TreeNode(rootVal);
+        const mid = map.get(rootVal) ?? 0;
+        const leftnum = mid - iStart;
+        root.left = helper(pStart + 1, pStart + leftnum, iStart, mid - 1);
+        root.right = helper(pStart + leftnum + 1, pEnd, mid + 1, iEnd);
+        return root;
+    }
+    return helper(0, preorder.length - 1, 0, inorder.length - 1);
 }
 export default buildTree;

permutations-ii/index.ts

@@ -1,8 +1,5 @@
-// const isEqual = _.isEqual;
-
 import { uniqBy } from "../deps.ts";
 
-// const uniqBy = _.uniqBy;
 export default function permuteUnique(nums: number[]): number[][] {
     if (nums.length == 0) {
         return [];
@@ -11,19 +8,10 @@ export default function permuteUnique(nums: number[]): number[][] {
         return [nums];
     }
 
-    // const visited = new Set<string>();
     const result: number[][] = [];
 
     permute_index(nums, (numsres: number[]) => {
-        // const numsres = indexs.map((v) => nums[v]);
-        // const numsres = indexs;
-        // const key = numsres.join(",");
-        // if (visited.has(key)) {
-        //     return;
-        // } else {
-        //     visited.add(key);
         result.push(numsres);
-        // }
     });
     return uniqBy(result, (a: number[]) => Array.prototype.join.call(a, ","));
 }
@@ -37,39 +25,21 @@ function permute_index(nums: number[], output: (indexs: number[]) => void) {
         output([0].map((v) => nums[v]));
         return;
     }
-    // if (k === 2) {
-    //     // output([0, 1].map((v) => nums[v]));
-    //     // output([1, 0].map((v) => nums[v]));
-    //     const arrays: number[][] = uniqBy(
-    //         [
-    //             [1, 0],
-    //             [0, 1],
-    //         ].map((a) => a.map((v) => nums[v])),
-    //         isEqual
-    //     );
-    //     console.log(arrays)
-    //     for (const res of arrays) {
-    //         output(res);
-    //     }
-    //     return;
-    // }
 
     permute_index(nums.slice(0, -1), (indexs) => {
         const arrays: number[][] = [];
         for (let i = 0; i < indexs.length + 1; i++) {
             const b = Array.from(indexs);
             b.splice(i, 0, nums.slice(-1)[0]);
             arrays.push(b);
-            // output(b);
         }
-        // console.log(arrays);
+
         for (
             const res of uniqBy(
                 arrays,
                 (a: number[]) => Array.prototype.join.call(a, ","),
             )
         ) {
-            // console.log(res);
             output(res);
         }
     });