add some prob-sols and update some approach

Author: realdennis

src/binary-search-tree/delete-node-in-bst.ts

@@ -1,35 +1,33 @@
 function deleteNode(root: TreeNode | null, key: number): TreeNode | null {
-    if (root === null) return root;
-    if (root.val === key) {
-        const { left, right } = root;
-        if (left === null) return right;
-        else if (right === null) return left;
-        let ptr = left;
-        while (ptr.right !== null) ptr = ptr.right;
-        ptr.right = right;
-        return left;
-    } else if (root.left && root.left.val === key) {
-        const { left, right } = root.left;
-        if (left === null) root.left = right;
-        else {
-            let ptr = left;
-            while (ptr.right !== null) ptr = ptr.right;
-            ptr.right = right;
-            root.left = left;
-        }
-    } else if (root.right && root.right.val === key) {
-        const { left, right } = root.right;
-        if (left === null) root.right = right;
-        else {
-            let ptr = left;
-            while (ptr.right !== null) ptr = ptr.right;
-            ptr.right = right;
-            root.right = left;
-        }
-    } else if (root.val < key) {
-        root.right = deleteNode(root.right, key);
-    } else {
+    // case 0. nothing to kill
+    if (root === null) return null;
+
+    // case 1. key in the root.left
+    if (key < root.val) {
         root.left = deleteNode(root.left, key);
+        return root;
+    }
+
+    // case 2. key in the root.right
+    if (key > root.val) {
+        root.right = deleteNode(root.right, key);
+        return root;
     }
+
+    // case 3. root is the key
+    const left = root.left,
+        right = root.right;
+
+    if (left === null) return right;
+    if (right === null) return left;
+
+    // so we need to remove the root, and choose a new root val
+    // from left's right-most (or right's left-most)
+    let ptr = left;
+    while (ptr.right !== null) ptr = ptr.right;
+
+    root.val = ptr.val;
+    root.left = deleteNode(left, ptr.val); // since we pick the left's rightmost, recursion kill this picked node
+
     return root;
 }

src/binary-search-tree/increasing-order-binary-search-tree.ts

@@ -1,20 +1,25 @@
 function increasingBST(root: TreeNode | null): TreeNode | null {
-    // do in order traversal first
-    if (root === null) return null;
+    // let's do morris traversal
+    let cur = root;
+    let prevRoot = new TreeNode(0);
+    let prev = prevRoot;
 
-    const inorder = (node: TreeNode | null): number[] => {
-        return node === null ? [] : [...inorder(node.left), node.val, ...inorder(node.right)];
-    };
+    while (cur !== null) {
+        if (cur.left !== null) {
+            const left = cur.left;
+            cur.left = null; // prune
 
-    const nodes = inorder(root);
-    const firstNode = nodes.shift()!;
+            let rightmost = left;
+            while (rightmost.right !== null) rightmost = rightmost.right;
+            rightmost.right = cur;
 
-    let _root = new TreeNode(firstNode);
-    const _root_ref = _root;
-    while (nodes.length !== 0) {
-        const node = nodes.shift()!;
-        _root.right = new TreeNode(node);
-        _root = _root.right;
+            cur = left;
+        } else {
+            prev.right = cur;
+            prev = prev.right;
+            cur = cur.right;
+        }
     }
-    return _root_ref;
+
+    return prevRoot.right;
 }

src/binary-search-tree/minimum-absolute-difference-in-bst.ts

@@ -0,0 +1,24 @@
+function getMinimumDifference(root: TreeNode | null): number {
+    let ret = Number.MAX_SAFE_INTEGER;
+
+    // Let's do the morris traversal
+    let cur = root;
+    let prev = Number.MIN_SAFE_INTEGER;
+    while (cur !== null) {
+        if (cur.left !== null) {
+            const left = cur.left;
+            cur.left = null; // prune
+
+            let rightmost = left;
+            while (rightmost.right !== null) rightmost = rightmost.right;
+            rightmost.right = cur;
+
+            cur = left;
+        } else {
+            ret = Math.min(ret, cur.val - prev);
+            prev = cur.val;
+            cur = cur.right;
+        }
+    }
+    return ret;
+}

src/binary-search-tree/trim-a-binary-search-tree.ts

@@ -3,9 +3,6 @@ function trimBST(root: TreeNode | null, low: number, high: number): TreeNode | n
     if (root.val < low) return trimBST(root.right, low, high);
     if (root.val > high) return trimBST(root.left, low, high);
 
-    if (root.right && root.right.val > high) root.right = root.right.left;
-    if (root.left && root.left.val < low) root.left = root.left.right;
-
     root.right = trimBST(root.right, low, high);
     root.left = trimBST(root.left, low, high);
     return root;

src/binary-tree/balanced-binary-tree.ts

@@ -0,0 +1,10 @@
+const getHeightOf = _.memoize((root: TreeNode | null): number =>
+    root === null ? 0 : 1 + Math.max(getHeightOf(root.left), getHeightOf(root.right))
+);
+function isBalanced(root: TreeNode | null): boolean {
+    return root === null
+        ? true
+        : isBalanced(root.left) &&
+              isBalanced(root.right) &&
+              Math.abs(getHeightOf(root.left) - getHeightOf(root.right)) <= 1;
+}

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

@@ -0,0 +1,17 @@
+function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
+    if (preorder.length === 0) return null;
+
+    const D = preorder.shift()!;
+    const partitionIdx = inorder.indexOf(D);
+
+    const leftInorder = inorder.slice(0, partitionIdx),
+        rightInorder = inorder.slice(partitionIdx + 1);
+
+    const leftPreorder = preorder.slice(0, partitionIdx),
+        rightPreorder = preorder.slice(partitionIdx);
+
+    const root = new TreeNode(D);
+    root.left = buildTree(leftPreorder, leftInorder);
+    root.right = buildTree(rightPreorder, rightInorder);
+    return root;
+}

src/binary-tree/count-complete-tree.ts

@@ -1,34 +1,27 @@
+const getLength = (node: TreeNode | null, direction: "left" | "right"): number =>
+    node === null ? 0 : getLength(node[direction], direction) + 1;
+
 function countNodes(root: TreeNode | null): number {
-    if (root === null) return 0;
+    let ret = 0;
 
-    const getHeight = (node: TreeNode | null): number => {
-        let height = 0;
-        let ptr = node;
-        while (ptr !== null) {
-            height++;
-            ptr = ptr.left;
-        }
-        return height;
-    };
-    const isFullTree = (node: TreeNode | null): boolean => {
-        if (node === null) return true;
-        let left = node.left,
-            right = node.right;
-        while (left !== null && right !== null) {
-            left = left.left;
-            right = right.right;
+    const backtracking = (node: TreeNode | null = root, prevRes = 1) => {
+        if (node === null) return;
+        if (node.left === null && node.right === null) {
+            ret = prevRes;
+            return;
         }
-        return left === right; // should be null in same time
-    };
-    const traversal = (node: TreeNode | null, lo: number, hi: number): number => {
-        let mi = Math.floor((lo + hi) / 2);
-        if (node === null || isFullTree(node)) return hi;
-        if (!isFullTree(node.right)) return traversal(node.right, mi + 1, hi);
-        if (!isFullTree(node.left)) return traversal(node.left, lo, mi);
+        const ll = getLength(node.left, "left"),
+            lr = getLength(node.left, "right"),
+            rl = getLength(node.right, "left");
 
-        return mi;
+        if (ll > lr || lr > rl) {
+            // means left subtree is not full-tree + left is full but last node still in left
+            backtracking(node.left, prevRes * 2);
+        } else {
+            backtracking(node.right, prevRes * 2 + 1);
+        }
     };
 
-    const treeHeight = getHeight(root);
-    return traversal(root, 2 ** (treeHeight - 1), 2 ** treeHeight - 1);
+    backtracking();
+    return ret;
 }

src/binary-tree/delete-nodes-and-return-forest.ts

@@ -0,0 +1,24 @@
+function delNodes(root: TreeNode | null, to_delete: number[]): (TreeNode | null)[] {
+    const shouldDelete = _.memoize(
+        (node: TreeNode | null) => node !== null && to_delete.includes(node.val)
+    );
+    const ret: (TreeNode | null)[] = [];
+    const backtracking = (node: TreeNode | null = root, isRoot = true): void => {
+        if (node === null) return;
+
+        const left = node.left,
+            right = node.right;
+
+        if (shouldDelete(left)) node.left = null;
+        if (shouldDelete(right)) node.right = null;
+
+        if (isRoot && !shouldDelete(node)) ret.push(node);
+
+        backtracking(left, shouldDelete(node));
+        backtracking(right, shouldDelete(node));
+    };
+
+    backtracking(root, true);
+
+    return ret;
+}

src/binary-tree/flatten-binary-tree-to-linked-list.ts

@@ -0,0 +1,19 @@
+function flatten(root: TreeNode | null) {
+    // morris traversal
+    let cur = root;
+    while (cur !== null) {
+        if (cur.left !== null) {
+            let right = cur.right;
+            let left = cur.left;
+
+            // prune
+            cur.left = null;
+
+            let rightmost = left;
+            while (rightmost.right !== null) rightmost = rightmost.right;
+            rightmost.right = right;
+            cur.right = left;
+        }
+        cur = cur.right;
+    }
+}

src/binary-tree/symmetric-tree.ts

@@ -0,0 +1,11 @@
+const compareSymmetric = (left: TreeNode | null, right: TreeNode | null): boolean => {
+    if (left === null && right === null) return true;
+    if (left === null || right === null) return false;
+    if (left.val !== right.val) return false;
+
+    return compareSymmetric(left.left, right.right) && compareSymmetric(left.right, right.left);
+};
+function isSymmetric(root: TreeNode | null): boolean {
+    if (root === null) return true;
+    return compareSymmetric(root.left, root.right);
+}