add leetcode challege for validate is Binary Search Tree

Author: sangtrandev00

src/algorithm/searching/validate-binary-search-tree.test.ts

@@ -0,0 +1,39 @@
+import { describe, test, expect } from 'bun:test';
+import { TreeNode, isValidBST } from './validate-binary-search-tree';
+
+describe('isValidBST', () => {
+    test('should return true for a valid BST', () => {
+        const tree = new TreeNode(2, new TreeNode(1), new TreeNode(3));
+        expect(isValidBST(tree)).toBe(true);
+    });
+
+    test('should return false for an invalid BST (left child greater than parent)', () => {
+        const tree = new TreeNode(5, new TreeNode(1), new TreeNode(4, new TreeNode(3), new TreeNode(6)));
+        expect(isValidBST(tree)).toBe(false);
+    });
+
+    test('should return false for an invalid BST (right child less than parent) - Special case for unbalance tree - will solve later!', () => {
+        const tree = new TreeNode(5, new TreeNode(4), new TreeNode(6, new TreeNode(3), new TreeNode(7)));
+        expect(isValidBST(tree)).toBe(false);
+    });
+
+    test('should return true for a single node tree', () => {
+        const tree = new TreeNode(1);
+        expect(isValidBST(tree)).toBe(true);
+    });
+
+    test('should return true for an empty tree', () => {
+        const tree = null;
+        expect(isValidBST(tree)).toBe(true);
+    });
+
+    test('should return true for a valid BST with duplicate values on the left', () => {
+        const tree = new TreeNode(2, new TreeNode(1), new TreeNode(2));
+        expect(isValidBST(tree)).toBe(false); // Duplicate values should invalidate the BST
+    });
+
+    test('should return true for a valid BST with duplicate values on the right', () => {
+        const tree = new TreeNode(2, new TreeNode(1), new TreeNode(2));
+        expect(isValidBST(tree)).toBe(false); // Duplicate values should invalidate the BST
+    });
+});

src/algorithm/searching/validate-binary-search-tree.ts

@@ -0,0 +1,58 @@
+/**
+ * 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)
+    }
+
+}
+
+export function isValidBST(root: TreeNode | null): boolean {
+    if (root == null) return true
+    let currentNode: any = root;
+    let list = []
+    let queue = []
+    queue.push(currentNode)
+
+    while (queue.length > 0) {
+        console.log(currentNode.val);
+        currentNode = queue.shift(); // O(n) => Queue để lưu trữ các node ở phía tước
+        list.push(currentNode.val) // O(1)
+        if (currentNode.left) {
+            if (currentNode.val <= currentNode.left.val) return false
+            queue.push(currentNode.left) // O(1)
+        }
+        if (currentNode.right) {
+            if (currentNode.val >= currentNode.right.val) return false
+            queue.push(currentNode.right) // O(1)
+        }
+    }
+
+    return true
+};
+
+const tree = new TreeNode(2, new TreeNode(1), new TreeNode(3));
+const tree2 = new TreeNode(5, new TreeNode(1, null, null), new TreeNode(4, new TreeNode(3), new TreeNode(6)));
+const tree3 = new TreeNode(5, new TreeNode(4, null, null), new TreeNode(6, new TreeNode(3), new TreeNode(7))); // Cây không cân bằng. Trường hợp này giải quyết như thế nào ?
+
+
+console.log(tree);
+console.log(isValidBST(tree));
+console.log(isValidBST(tree2));