add DSA Binary Search Tree and its unitest

Author: sangtrandev00

src/data_structure/binarySearchTree/binarySearchTree-implement.test.ts

@@ -1 +1,71 @@
 
+import { describe, it, expect, beforeEach } from 'bun:test';
+import { BinarySearchTree } from './binarySearchTree-implement';
+
+
+describe('BinarySearchTree', () => {
+ let tree: BinarySearchTree;
+
+ beforeEach(() => {
+ tree = new BinarySearchTree();
+ });
+
+ it('should insert nodes correctly', () => {
+ tree.insert(10);
+ tree.insert(5);
+ tree.insert(15);
+ expect(tree.lookup(10)).toBeTruthy();
+ expect(tree.lookup(5)).toBeTruthy();
+ expect(tree.lookup(15)).toBeTruthy();
+ expect(tree.lookup(20)).toBeFalsy(); // Not inserted
+ });
+
+ it('should lookup nodes correctly', () => {
+ tree.insert(10);
+ tree.insert(5);
+ tree.insert(15);
+ expect(tree.lookup(10)).toEqual(expect.objectContaining({ value: 10 }));
+ expect(tree.lookup(5)).toEqual(expect.objectContaining({ value: 5 }));
+ expect(tree.lookup(15)).toEqual(expect.objectContaining({ value: 15 }));
+ expect(tree.lookup(20)).toBeFalsy(); // Not inserted
+ });
+
+ it('should remove nodes correctly', () => {
+ tree.insert(10);
+ tree.insert(5);
+ tree.insert(15);
+ expect(tree.remove(5)).toBeTruthy();
+ expect(tree.lookup(5)).toBeFalsy(); // Should be removed
+ expect(tree.remove(10)).toBeTruthy();
+ expect(tree.lookup(10)).toBeFalsy(); // Should be removed
+ expect(tree.remove(15)).toBeTruthy();
+ expect(tree.lookup(15)).toBeFalsy(); // Should be removed
+ });
+
+ it('should handle removing a node with one child', () => {
+ tree.insert(10);
+ tree.insert(5);
+ tree.insert(15);
+ tree.insert(12);
+ expect(tree.remove(15)).toBeTruthy();
+ expect(tree.lookup(15)).toBeFalsy(); // Should be removed
+ expect(tree.lookup(12)).toEqual(expect.objectContaining({ value: 12 })); // Should still exist
+ });
+
+ it('should handle removing a node with two children', () => {
+ tree.insert(10);
+ tree.insert(5);
+ tree.insert(15);
+ tree.insert(12);
+ tree.insert(17);
+ expect(tree.remove(15)).toBeTruthy();
+ expect(tree.lookup(15)).toBeFalsy(); // Should be removed
+ expect(tree.lookup(12)).toEqual(expect.objectContaining({ value: 12 })); // Should still exist
+ expect(tree.lookup(17)).toEqual(expect.objectContaining({ value: 17 })); // Should still exist
+ });
+
+ it('should return false when removing a non-existent node', () => {
+ tree.insert(10);
+ expect(tree.remove(20)).toBeFalsy(); // Node does not exist
+ });
+});

src/data_structure/binarySearchTree/binarySearchTree-implement.ts

@@ -1,7 +1,6 @@
-
 class Node {
- left: any;
- right: any;
+ left: Node | null;
+ right: Node | null;;
  value: number;
  constructor(value: number) {
  this.left = null;
@@ -10,28 +9,132 @@ class Node {
  }
 }
 
-class BinarySearchTree {
- root: any
+export class BinarySearchTree {
+ root: Node | null;
  constructor() {
  this.root = null;
  }
  insert(value: number) {
+ const newNode = new Node(value);
+
  if (this.root === null) {
- this.root = new Node(value)
+ this.root = newNode;
+ } else {
+ let currentNode = this.root;
+ while (true) {
+ if (currentNode.value > value) {
+ // Left
+ if (!currentNode.left) {
+ currentNode.left = newNode;
+ return this;
+ }
+ currentNode = currentNode.left;
+ } else {
+ // Right
+ if (!currentNode.right) {
+ currentNode.right = newNode;
+ return this;
+ }
+ currentNode = currentNode.right;
+ }
+ }
  }
- // Làm sao để lặp qua (Chẳng lẽ sử dụng recursion)
-
- // So sánh 
-
- // Gán giá trị
-
  }
  lookup(value: number) {
+ if (!this.root) {
+ return false;
+ }
+ let currentNode: Node | null = this.root;
 
+ while (currentNode) {
+ if (currentNode.value > value) {
+ // Left
+ currentNode = currentNode.left;
+ } else if (currentNode.value < value) {
+ // Right
+ currentNode = currentNode.right;
+ } else if (currentNode.value === value) {
+ return currentNode;
+ }
+ }
+ return false;
  }
 
  remove(value: number) {
+ if (!this.root) {
+ return false;
+ }
+ let currentNode: Node | null = this.root;
+ let parentNode = null;
+ while (currentNode) {
+ if (value < currentNode.value) {
+ parentNode = currentNode;
+ currentNode = currentNode.left;
+ } else if (value > currentNode.value) {
+ parentNode = currentNode;
+ currentNode = currentNode.right;
+ } else if (currentNode.value === value) {
+ //We have a match, get to work!
 
+ //Option 1: No right child:
+ if (currentNode.right === null) {
+ if (parentNode === null) {
+ this.root = currentNode.left;
+ } else {
+ //if parent > current value, make current left child a child of parent
+ if (currentNode.value < parentNode.value) {
+ parentNode.left = currentNode.left;
+
+ //if parent < current value, make left child a right child of parent
+ } else if (currentNode.value > parentNode.value) {
+ parentNode.right = currentNode.left;
+ }
+ }
+
+ //Option 2: Right child which doesnt have a left child
+ } else if (currentNode.right.left === null) {
+ currentNode.right.left = currentNode.left;
+ if (parentNode === null) {
+ this.root = currentNode.right;
+ } else {
+ //if parent > current, make right child of the left the parent
+ if (currentNode.value < parentNode.value) {
+ parentNode.left = currentNode.right;
+
+ //if parent < current, make right child a right child of the parent
+ } else if (currentNode.value > parentNode.value) {
+ parentNode.right = currentNode.right;
+ }
+ }
+
+ //Option 3: Right child that has a left child
+ } else {
+ //find the Right child's left most child
+ let leftmost = currentNode.right.left;
+ let leftmostParent = currentNode.right;
+ while (leftmost.left !== null) {
+ leftmostParent = leftmost;
+ leftmost = leftmost.left;
+ }
+
+ //Parent's left subtree is now leftmost's right subtree
+ leftmostParent.left = leftmost.right;
+ leftmost.left = currentNode.left;
+ leftmost.right = currentNode.right;
+
+ if (parentNode === null) {
+ this.root = leftmost;
+ } else {
+ if (currentNode.value < parentNode.value) {
+ parentNode.left = leftmost;
+ } else if (currentNode.value > parentNode.value) {
+ parentNode.right = leftmost;
+ }
+ }
+ }
+ return true;
+ }
+ }
  }
 }
 
@@ -46,13 +149,13 @@ tree.insert(1);
 tree.remove(170);
 JSON.stringify(traverse(tree.root));
 console.log(tree.lookup(20));
-
 // 9
 // 4 20
 //1 6 15 170
 
-function traverse(node: any) {
- const tree: any = { value: node.value };
+function traverse(node: Node | null) {
+ if (!node) return null
+ const tree: Node | null = { value: node.value, left: null, right: null };
  tree.left = node.left === null ? null : traverse(node.left);
  tree.right = node.right === null ? null : traverse(node.right);
  return tree;