Solve LeetCode 75 binary tree DFS problems

Author: THammami01

LeetCode-75/33-104.ts

@@ -0,0 +1,26 @@
+// https://leetcode.com/problems/maximum-depth-of-binary-tree/?envType=study-plan-v2&envId=leetcode-75
+
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+// @ts-nocheck
+const depthFirstMaxDepth = (root: TreeNode | null, depth: number): number => {
+  if (root === null) return depth;
+
+  const leftDepth = depthFirstMaxDepth(root.left, depth + 1);
+  const rightDepth = depthFirstMaxDepth(root.right, depth + 1);
+  return Math.max(leftDepth, rightDepth);
+};
+
+const maxDepth = (root: TreeNode | null): number => depthFirstMaxDepth(root, 0);

LeetCode-75/34-872.ts

@@ -0,0 +1,29 @@
+// https://leetcode.com/problems/leaf-similar-trees/?envType=study-plan-v2&envId=leetcode-75
+
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+// @ts-nocheck
+const depthFirstLeafSequence = (root: TreeNode | null): number[] => {
+  if (root === null) return [];
+  if (root.left === null && root.right === null) return [root.val];
+
+  const leftVals = depthFirstLeafSequence(root.left);
+  const rightVal = depthFirstLeafSequence(root.right);
+  return [...leftVals, ...rightVal];
+};
+
+const leafSimilar = (root1: TreeNode | null, root2: TreeNode | null): boolean =>
+  depthFirstLeafSequence(root1).join(",") ===
+  depthFirstLeafSequence(root2).join(",");

LeetCode-75/35-1448.ts

@@ -0,0 +1,31 @@
+// https://leetcode.com/problems/path-sum-iii/description/?envType=study-plan-v2&envId=leetcode-75
+
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+// @ts-nocheck
+const depthFirstGoodCount = (root: TreeNode | null, max: number): number => {
+  if (root === null) return 0;
+
+  max = Math.max(root.val, max);
+
+  return (
+    (root.val === max ? 1 : 0) +
+    depthFirstGoodCount(root.left, max) +
+    depthFirstGoodCount(root.right, max)
+  );
+};
+
+const goodNodes = (root: TreeNode | null): number =>
+  depthFirstGoodCount(root, root.val);

LeetCode-75/36-437.ts

@@ -0,0 +1,62 @@
+// https://leetcode.com/problems/path-sum-iii/description/?envType=study-plan-v2&envId=leetcode-75
+
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+// @ts-nocheck
+const depthFirstPathSumCount = (
+  root: TreeNode | null,
+  targetSum: number,
+  pathSumMap: Map<TreeNode, number>
+): number[] => {
+  if (root === null) return [0, 0];
+
+  pathSumMap.set(root, root.val);
+
+  let localPathSumCount = 0;
+
+  pathSumMap.forEach((val, key) => {
+    if (key !== root) val += root.val;
+    if (val === targetSum) localPathSumCount++;
+    pathSumMap.set(key, val);
+  });
+
+  const [leftTreePathSumCount, leftChildVal] = depthFirstPathSumCount(
+    root.left,
+    targetSum,
+    pathSumMap
+  );
+
+  if (leftChildVal)
+    pathSumMap.forEach((val, key) => pathSumMap.set(key, val - leftChildVal));
+
+  const [rightTreePathSumCount, rightChildVal] = depthFirstPathSumCount(
+    root.right,
+    targetSum,
+    pathSumMap
+  );
+
+  pathSumMap.delete(root);
+
+  if (rightChildVal)
+    pathSumMap.forEach((val, key) => pathSumMap.set(key, val - rightChildVal));
+
+  return [
+    localPathSumCount + leftTreePathSumCount + rightTreePathSumCount,
+    root.val,
+  ];
+};
+
+const pathSum = (root: TreeNode | null, targetSum: number): number =>
+  depthFirstPathSumCount(root, targetSum, new Map())[0];

LeetCode-75/37-1372.ts

@@ -0,0 +1,41 @@
+// https://leetcode.com/problems/longest-zigzag-path-in-a-binary-tree/description/?envType=study-plan-v2&envId=leetcode-75
+
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+// @ts-nocheck
+const depthFirstLongestZigZagPath = (
+  root: TreeNode | null,
+  direction: "L" | "R" | null
+): { currMax: number; max: number } => {
+  if (root === null) return { currMax: 0, max: 0 };
+
+  const rightRes = depthFirstLongestZigZagPath(root.right, "R");
+  const leftRes = depthFirstLongestZigZagPath(root.left, "L");
+
+  const max = Math.max(rightRes.max, leftRes.max);
+
+  if (direction === "L") {
+    const currMax = rightRes.currMax + 1;
+    return { currMax, max: Math.max(currMax, max) };
+  } else if (direction === "R") {
+    const currMax = leftRes.currMax + 1;
+    return { currMax, max: Math.max(currMax, max) };
+  } else {
+    return { currMax: max, max };
+  }
+};
+
+const longestZigZag = (root: TreeNode | null): number =>
+  depthFirstLongestZigZagPath(root, null).max;

LeetCode-75/38-236.ts

@@ -0,0 +1,44 @@
+// https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/?envType=study-plan-v2&envId=leetcode-75
+
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+// @ts-nocheck
+const depthFirstLowestCommonAncestor = (
+  root: TreeNode | null,
+  p: TreeNode | null,
+  q: TreeNode | null
+): TreeNode[] => {
+  if (root === null) return [];
+
+  const res = [
+    ...depthFirstLowestCommonAncestor(root.left, p, q),
+    ...depthFirstLowestCommonAncestor(root.right, p, q),
+  ];
+
+  if (res.length === 3) return res;
+
+  if (res.length === 2 || root === p || root === q) {
+    res.push(root);
+    if (res.length === 2) res.push(root);
+  }
+
+  return res;
+};
+
+const lowestCommonAncestor = (
+  root: TreeNode | null,
+  p: TreeNode | null,
+  q: TreeNode | null
+): TreeNode | null => depthFirstLowestCommonAncestor(root, p, q)[2];

README.md

@@ -60,12 +60,12 @@
 
 ### Binary Tree - DFS
 
-- [ ] 33. Maximum Depth of Binary Tree
-- [ ] 34. Leaf-Similar Trees
-- [ ] 35. Count Good Nodes in Binary Tree
-- [ ] 36. Path Sum III
-- [ ] 37. Longest ZigZag Path in a Binary Tree
-- [ ] 38. Lowest Common Ancestor of a Binary Tree
+- [X] 33. Maximum Depth of Binary Tree
+- [X] 34. Leaf-Similar Trees
+- [X] 35. Count Good Nodes in Binary Tree
+- [X] 36. Path Sum III
+- [X] 37. Longest ZigZag Path in a Binary Tree
+- [X] 38. Lowest Common Ancestor of a Binary Tree
 
 ### Binary Tree - BFS