up coding excercise lowest common ansertor

Author: sangtrandev00

src/algorithm/searching/bfs-dfs.ts

@@ -246,7 +246,7 @@ export class BinarySearchTree {
 //1 6 15 170
 // InOrder - Left -> Root -> Right: [1, 4, 6, 9, 15, 20, 170]
 // PreOrder - Root -> Left -> Right: [9, 4, 1, 6, 20, 15, 170]
-// PostOrder - Left -> Right -> Root: [1, 4, 6, 9, 15, 20, 170]
+// PostOrder - Left -> Right -> Root: [1, 6, 4, 15, 170, 20, 9]
 
 const tree = new BinarySearchTree();
 tree.insert(9);

src/leetcode/binary_tree/lowest-common-ansertor.test.ts

@@ -0,0 +1,67 @@
+import { describe, test, expect } from 'bun:test'
+import { lowestCommonAncestor, TreeNode } from './lowest-common-ansertor';
+
+describe('lowestCommonAncestor', () => {
+ test('should return null for an empty tree', () => {
+ expect(lowestCommonAncestor(null, null, null)).toBeNull();
+ });
+
+ test('should return the root for the same node', () => {
+ const root = new TreeNode(1);
+ expect(lowestCommonAncestor(root, root, root)).toBe(root);
+ });
+
+ test('should return the root as LCA when one node is the root', () => {
+ const root = new TreeNode(1, new TreeNode(2), new TreeNode(3));
+ expect(lowestCommonAncestor(root, root, root.left)).toBe(root);
+ expect(lowestCommonAncestor(root, root, root.right)).toBe(root);
+ });
+
+ test('should return the correct LCA for two nodes on the same level', () => {
+ const root = new TreeNode(3, new TreeNode(2), new TreeNode(4));
+ expect(lowestCommonAncestor(root, root.left, root.right)).toBe(root);
+ });
+
+ test('should return the correct LCA for two nodes in the left subtree', () => {
+ const root = new TreeNode(5,
+ new TreeNode(3, new TreeNode(2), new TreeNode(4)),
+ new TreeNode(8)
+ );
+ if (root.left && root.left.left && root.left.right) {
+ expect(lowestCommonAncestor(root, root.left.left, root.left.right)).toBe(root.left);
+ }
+ });
+
+ test('should return the correct LCA for two nodes in the right subtree', () => {
+ const root = new TreeNode(5,
+ new TreeNode(3),
+ new TreeNode(8, new TreeNode(7), new TreeNode(9))
+ );
+ if (root.right && root.right.left && root.right.right) {
+ expect(lowestCommonAncestor(root, root.right.left, root.right.right)).toBe(root.right);
+ }
+ });
+
+ test('should return the correct LCA for nodes in different subtrees', () => {
+ const root = new TreeNode(6,
+ new TreeNode(2, new TreeNode(0), new TreeNode(4, new TreeNode(3), new TreeNode(5))),
+ new TreeNode(8, new TreeNode(7), new TreeNode(9))
+ );
+ if (root.left && root.right) {
+ expect(lowestCommonAncestor(root, root.left, root.right)).toBe(root);
+ if (root.left.left) {
+ expect(lowestCommonAncestor(root, root.left.left, root.right)).toBe(root);
+ }
+ }
+ });
+
+ test('should return the correct LCA for nodes that are not direct children', () => {
+ const root = new TreeNode(6,
+ new TreeNode(2, new TreeNode(0), new TreeNode(4, new TreeNode(3), new TreeNode(5))),
+ new TreeNode(8, new TreeNode(7), new TreeNode(9))
+ );
+ if (root.left && root.left.right && root.left.right.left && root.left.right.right) {
+ expect(lowestCommonAncestor(root, root.left.right.left, root.left.right.right)).toBe(root.left.right);
+ }
+ });
+});

src/leetcode/binary_tree/lowest-common-ansertor.ts

@@ -0,0 +1,50 @@
+/**
+ * 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)
+ * }
+ * }
+ */
+
+export 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)
+ }
+}
+
+// Sử dụng trường hợp không đệ quy (độ phức tạp: Time complexity O(h) -> O(n) Trường hợp cây không cân bằng
+// Space complexity 
+export function lowestCommonAncestor(root: TreeNode | null, p: TreeNode | null, q: TreeNode | null): TreeNode | null {
+ if (!p || !q) return null
+
+ let currentNode = root;
+ while (currentNode != null) {
+ const currentVal = currentNode.val
+ if (p.val < currentVal && q.val > currentVal || p.val > currentVal && q.val < currentVal) {
+ return currentNode
+ } else if (p.val < currentVal && q.val < currentVal) {
+ currentNode = currentNode.left
+ } else if (p.val > currentVal && q.val > currentVal) {
+ currentNode = currentNode.right
+ } else if (p.val == currentVal || q.val == currentVal) {
+ return currentNode
+ }
+ }
+
+ return root;
+};
+
+// console.log("lowestCommonAncestor", lowestCommonAncestor(new TreeNode(2, new TreeNode(1), null), new TreeNode(2), new TreeNode(1)));
+// console.log("lowestCommonAncestor", lowestCommonAncestor(new TreeNode(6, new TreeNode(2, new TreeNode(0), new TreeNode(4, new TreeNode(3), new TreeNode(5))), new TreeNode(8, new TreeNode(7), new TreeNode(8))), new TreeNode(2), new TreeNode(8)));
+console.log("lowestCommonAncestor", lowestCommonAncestor(new TreeNode(2, new TreeNode(1), new TreeNode(3)), new TreeNode(3), new TreeNode(1)));