data-structure-typed 1.33.9 → 1.33.10

package/test/unit/data-structures/binary-tree/bst.test.ts

@@ -0,0 +1,380 @@
+import {BST, BSTNode} from '../../../../src';
+
+describe('BST operations test', () => {
+  it('should perform various operations on a Binary Search Tree with numeric values', () => {
+    const bst = new BST();
+    expect(bst).toBeInstanceOf(BST);
+    bst.add(11, 11);
+    bst.add(3, 3);
+    const idsAndValues = [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    bst.addMany(idsAndValues, idsAndValues);
+    expect(bst.root).toBeInstanceOf(BSTNode);
+
+    if (bst.root) expect(bst.root.id).toBe(11);
+
+    expect(bst.size).toBe(16);
+
+    expect(bst.has(6)).toBe(true);
+
+    const node6 = bst.get(6);
+    expect(node6 && bst.getHeight(6)).toBe(2);
+    expect(node6 && bst.getDepth(6)).toBe(3);
+
+    const nodeId10 = bst.get(10);
+    expect(nodeId10?.id).toBe(10);
+
+    const nodeVal9 = bst.get(9, 'val');
+    expect(nodeVal9?.id).toBe(9);
+
+    const leftMost = bst.getLeftMost();
+    expect(leftMost?.id).toBe(1);
+
+    const node15 = bst.get(15);
+    const minNodeBySpecificNode = node15 && bst.getLeftMost(node15);
+    expect(minNodeBySpecificNode?.id).toBe(12);
+
+    const subTreeSum = node15 && bst.subTreeSum(15);
+    expect(subTreeSum).toBe(70);
+
+    const lesserSum = bst.lesserSum(10);
+    expect(lesserSum).toBe(45);
+
+    expect(node15).toBeInstanceOf(BSTNode);
+
+    const node11 = bst.get(11);
+    expect(node11).toBeInstanceOf(BSTNode);
+
+    const dfsInorderNodes = bst.DFS('in', 'node');
+    expect(dfsInorderNodes[0].id).toBe(1);
+    expect(dfsInorderNodes[dfsInorderNodes.length - 1].id).toBe(16);
+
+    bst.perfectlyBalance();
+    expect(bst.isPerfectlyBalanced()).toBe(true);
+
+    const bfsNodesAfterBalanced = bst.BFS('node');
+    expect(bfsNodesAfterBalanced[0].id).toBe(8);
+    expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].id).toBe(16);
+
+    const removed11 = bst.remove(11);
+    expect(removed11).toBeInstanceOf(Array);
+    expect(removed11[0]).toBeDefined();
+    expect(removed11[0].deleted).toBeDefined();
+
+    if (removed11[0].deleted) expect(removed11[0].deleted.id).toBe(11);
+
+    expect(bst.isAVLBalanced()).toBe(true);
+
+    expect(bst.getHeight(15)).toBe(1);
+
+    const removed1 = bst.remove(1);
+    expect(removed1).toBeInstanceOf(Array);
+    expect(removed1[0]).toBeDefined();
+    expect(removed1[0].deleted).toBeDefined();
+    if (removed1[0].deleted) expect(removed1[0].deleted.id).toBe(1);
+
+    expect(bst.isAVLBalanced()).toBe(true);
+
+    expect(bst.getHeight()).toBe(4);
+
+    const removed4 = bst.remove(4);
+    expect(removed4).toBeInstanceOf(Array);
+    expect(removed4[0]).toBeDefined();
+    expect(removed4[0].deleted).toBeDefined();
+    if (removed4[0].deleted) expect(removed4[0].deleted.id).toBe(4);
+    expect(bst.isAVLBalanced()).toBe(true);
+    expect(bst.getHeight()).toBe(4);
+
+    const removed10 = bst.remove(10);
+    expect(removed10).toBeInstanceOf(Array);
+    expect(removed10[0]).toBeDefined();
+    expect(removed10[0].deleted).toBeDefined();
+    if (removed10[0].deleted) expect(removed10[0].deleted.id).toBe(10);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(4);
+
+    const removed15 = bst.remove(15);
+    expect(removed15).toBeInstanceOf(Array);
+    expect(removed15[0]).toBeDefined();
+    expect(removed15[0].deleted).toBeDefined();
+    if (removed15[0].deleted) expect(removed15[0].deleted.id).toBe(15);
+
+    expect(bst.isAVLBalanced()).toBe(true);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed5 = bst.remove(5);
+    expect(removed5).toBeInstanceOf(Array);
+    expect(removed5[0]).toBeDefined();
+    expect(removed5[0].deleted).toBeDefined();
+    if (removed5[0].deleted) expect(removed5[0].deleted.id).toBe(5);
+
+    expect(bst.isAVLBalanced()).toBe(true);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed13 = bst.remove(13);
+    expect(removed13).toBeInstanceOf(Array);
+    expect(removed13[0]).toBeDefined();
+    expect(removed13[0].deleted).toBeDefined();
+    if (removed13[0].deleted) expect(removed13[0].deleted.id).toBe(13);
+    expect(bst.isAVLBalanced()).toBe(true);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed3 = bst.remove(3);
+    expect(removed3).toBeInstanceOf(Array);
+    expect(removed3[0]).toBeDefined();
+    expect(removed3[0].deleted).toBeDefined();
+    if (removed3[0].deleted) expect(removed3[0].deleted.id).toBe(3);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed8 = bst.remove(8);
+    expect(removed8).toBeInstanceOf(Array);
+    expect(removed8[0]).toBeDefined();
+    expect(removed8[0].deleted).toBeDefined();
+    if (removed8[0].deleted) expect(removed8[0].deleted.id).toBe(8);
+    expect(bst.isAVLBalanced()).toBe(true);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed6 = bst.remove(6);
+    expect(removed6).toBeInstanceOf(Array);
+    expect(removed6[0]).toBeDefined();
+    expect(removed6[0].deleted).toBeDefined();
+    if (removed6[0].deleted) expect(removed6[0].deleted.id).toBe(6);
+    expect(bst.remove(6).length).toBe(0);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed7 = bst.remove(7);
+    expect(removed7).toBeInstanceOf(Array);
+    expect(removed7[0]).toBeDefined();
+    expect(removed7[0].deleted).toBeDefined();
+    if (removed7[0].deleted) expect(removed7[0].deleted.id).toBe(7);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed9 = bst.remove(9);
+    expect(removed9).toBeInstanceOf(Array);
+    expect(removed9[0]).toBeDefined();
+    expect(removed9[0].deleted).toBeDefined();
+    if (removed9[0].deleted) expect(removed9[0].deleted.id).toBe(9);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(3);
+
+    const removed14 = bst.remove(14);
+    expect(removed14).toBeInstanceOf(Array);
+    expect(removed14[0]).toBeDefined();
+    expect(removed14[0].deleted).toBeDefined();
+    if (removed14[0].deleted) expect(removed14[0].deleted.id).toBe(14);
+    expect(bst.isAVLBalanced()).toBe(false);
+    expect(bst.getHeight()).toBe(2);
+
+    expect(bst.isAVLBalanced()).toBe(false);
+
+    const bfsIDs = bst.BFS();
+    expect(bfsIDs[0]).toBe(2);
+    expect(bfsIDs[1]).toBe(12);
+    expect(bfsIDs[2]).toBe(16);
+
+    const bfsNodes = bst.BFS('node');
+    expect(bfsNodes[0].id).toBe(2);
+    expect(bfsNodes[1].id).toBe(12);
+    expect(bfsNodes[2].id).toBe(16);
+  });
+
+  it('should perform various operations on a Binary Search Tree with object values', () => {
+    const objBST = new BST<BSTNode<{id: number; keyA: number}>>();
+    expect(objBST).toBeInstanceOf(BST);
+    objBST.add(11, {id: 11, keyA: 11});
+    objBST.add(3, {id: 3, keyA: 3});
+    const values = [
+      {id: 15, keyA: 15},
+      {id: 1, keyA: 1},
+      {id: 8, keyA: 8},
+      {id: 13, keyA: 13},
+      {id: 16, keyA: 16},
+      {id: 2, keyA: 2},
+      {id: 6, keyA: 6},
+      {id: 9, keyA: 9},
+      {id: 12, keyA: 12},
+      {id: 14, keyA: 14},
+      {id: 4, keyA: 4},
+      {id: 7, keyA: 7},
+      {id: 10, keyA: 10},
+      {id: 5, keyA: 5}
+    ];
+
+    objBST.addMany(
+      values.map(item => item.id),
+      values
+    );
+
+    expect(objBST.root).toBeInstanceOf(BSTNode);
+
+    if (objBST.root) expect(objBST.root.id).toBe(11);
+
+    expect(objBST.has(6)).toBe(true);
+
+    const node6 = objBST.get(6);
+    expect(node6 && objBST.getHeight(node6)).toBe(2);
+    expect(node6 && objBST.getDepth(node6)).toBe(3);
+
+    const nodeId10 = objBST.get(10, 'id');
+    expect(nodeId10?.id).toBe(10);
+
+    const nodeVal9 = objBST.get(9, 'id');
+    expect(nodeVal9?.id).toBe(9);
+
+    const leftMost = objBST.getLeftMost();
+    expect(leftMost?.id).toBe(1);
+
+    const node15 = objBST.get(15);
+    expect(node15?.val).toEqual({id: 15, keyA: 15});
+    const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
+    expect(minNodeBySpecificNode?.id).toBe(12);
+
+    const subTreeSum = node15 && objBST.subTreeSum(node15);
+    expect(subTreeSum).toBe(70);
+
+    const lesserSum = objBST.lesserSum(10);
+    expect(lesserSum).toBe(45);
+
+    expect(node15).toBeInstanceOf(BSTNode);
+
+    const node11 = objBST.get(11);
+    expect(node11).toBeInstanceOf(BSTNode);
+
+    const dfsInorderNodes = objBST.DFS('in', 'node');
+    expect(dfsInorderNodes[0].id).toBe(1);
+    expect(dfsInorderNodes[dfsInorderNodes.length - 1].id).toBe(16);
+
+    objBST.perfectlyBalance();
+    expect(objBST.isPerfectlyBalanced()).toBe(true);
+
+    const bfsNodesAfterBalanced = objBST.BFS('node');
+    expect(bfsNodesAfterBalanced[0].id).toBe(8);
+    expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].id).toBe(16);
+
+    const removed11 = objBST.remove(11);
+    expect(removed11).toBeInstanceOf(Array);
+    expect(removed11[0]).toBeDefined();
+    expect(removed11[0].deleted).toBeDefined();
+
+    if (removed11[0].deleted) expect(removed11[0].deleted.id).toBe(11);
+
+    expect(objBST.isAVLBalanced()).toBe(true);
+
+    expect(node15 && objBST.getHeight(node15)).toBe(2);
+
+    const removed1 = objBST.remove(1);
+    expect(removed1).toBeInstanceOf(Array);
+    expect(removed1[0]).toBeDefined();
+    expect(removed1[0].deleted).toBeDefined();
+    if (removed1[0].deleted) expect(removed1[0].deleted.id).toBe(1);
+
+    expect(objBST.isAVLBalanced()).toBe(true);
+
+    expect(objBST.getHeight()).toBe(4);
+
+    const removed4 = objBST.remove(4);
+    expect(removed4).toBeInstanceOf(Array);
+    expect(removed4[0]).toBeDefined();
+    expect(removed4[0].deleted).toBeDefined();
+    if (removed4[0].deleted) expect(removed4[0].deleted.id).toBe(4);
+    expect(objBST.isAVLBalanced()).toBe(true);
+    expect(objBST.getHeight()).toBe(4);
+
+    const removed10 = objBST.remove(10);
+    expect(removed10).toBeInstanceOf(Array);
+    expect(removed10[0]).toBeDefined();
+    expect(removed10[0].deleted).toBeDefined();
+    if (removed10[0].deleted) expect(removed10[0].deleted.id).toBe(10);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(4);
+
+    const removed15 = objBST.remove(15);
+    expect(removed15).toBeInstanceOf(Array);
+    expect(removed15[0]).toBeDefined();
+    expect(removed15[0].deleted).toBeDefined();
+    if (removed15[0].deleted) expect(removed15[0].deleted.id).toBe(15);
+
+    expect(objBST.isAVLBalanced()).toBe(true);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed5 = objBST.remove(5);
+    expect(removed5).toBeInstanceOf(Array);
+    expect(removed5[0]).toBeDefined();
+    expect(removed5[0].deleted).toBeDefined();
+    if (removed5[0].deleted) expect(removed5[0].deleted.id).toBe(5);
+
+    expect(objBST.isAVLBalanced()).toBe(true);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed13 = objBST.remove(13);
+    expect(removed13).toBeInstanceOf(Array);
+    expect(removed13[0]).toBeDefined();
+    expect(removed13[0].deleted).toBeDefined();
+    if (removed13[0].deleted) expect(removed13[0].deleted.id).toBe(13);
+    expect(objBST.isAVLBalanced()).toBe(true);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed3 = objBST.remove(3);
+    expect(removed3).toBeInstanceOf(Array);
+    expect(removed3[0]).toBeDefined();
+    expect(removed3[0].deleted).toBeDefined();
+    if (removed3[0].deleted) expect(removed3[0].deleted.id).toBe(3);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed8 = objBST.remove(8);
+    expect(removed8).toBeInstanceOf(Array);
+    expect(removed8[0]).toBeDefined();
+    expect(removed8[0].deleted).toBeDefined();
+    if (removed8[0].deleted) expect(removed8[0].deleted.id).toBe(8);
+    expect(objBST.isAVLBalanced()).toBe(true);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed6 = objBST.remove(6);
+    expect(removed6).toBeInstanceOf(Array);
+    expect(removed6[0]).toBeDefined();
+    expect(removed6[0].deleted).toBeDefined();
+    if (removed6[0].deleted) expect(removed6[0].deleted.id).toBe(6);
+    expect(objBST.remove(6).length).toBe(0);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed7 = objBST.remove(7);
+    expect(removed7).toBeInstanceOf(Array);
+    expect(removed7[0]).toBeDefined();
+    expect(removed7[0].deleted).toBeDefined();
+    if (removed7[0].deleted) expect(removed7[0].deleted.id).toBe(7);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed9 = objBST.remove(9);
+    expect(removed9).toBeInstanceOf(Array);
+    expect(removed9[0]).toBeDefined();
+    expect(removed9[0].deleted).toBeDefined();
+    if (removed9[0].deleted) expect(removed9[0].deleted.id).toBe(9);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(3);
+
+    const removed14 = objBST.remove(14);
+    expect(removed14).toBeInstanceOf(Array);
+    expect(removed14[0]).toBeDefined();
+    expect(removed14[0].deleted).toBeDefined();
+    if (removed14[0].deleted) expect(removed14[0].deleted.id).toBe(14);
+    expect(objBST.isAVLBalanced()).toBe(false);
+    expect(objBST.getHeight()).toBe(2);
+
+    expect(objBST.isAVLBalanced()).toBe(false);
+
+    const bfsIDs = objBST.BFS();
+    expect(bfsIDs[0]).toBe(2);
+    expect(bfsIDs[1]).toBe(12);
+    expect(bfsIDs[2]).toBe(16);
+
+    const bfsNodes = objBST.BFS('node');
+    expect(bfsNodes[0].id).toBe(2);
+    expect(bfsNodes[1].id).toBe(12);
+    expect(bfsNodes[2].id).toBe(16);
+  });
+});

package/test/unit/data-structures/binary-tree/overall.test.ts

@@ -0,0 +1,65 @@
+import {AVLTree, BST, BSTNode} from '../../../../src';
+
+describe('Overall BinaryTree Test', () => {
+  it('should perform various operations on BinaryTree', () => {
+    const bst = new BST();
+    bst.add(11);
+    bst.add(3);
+    bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
+    bst.size === 16; // true
+    expect(bst.size).toBe(16); // true
+    bst.has(6); // true
+    expect(bst.has(6)).toBe(true); // true
+    bst.getHeight(6) === 2; // true
+    bst.getHeight() === 5; // true
+    bst.getDepth(6) === 3; // true
+    expect(bst.getHeight(6)).toBe(2); // true
+    expect(bst.getHeight()).toBe(5); // true
+    expect(bst.getDepth(6)).toBe(3); // true
+    const leftMost = bst.getLeftMost();
+    leftMost?.id === 1; // true
+    expect(leftMost?.id).toBe(1);
+    bst.remove(6);
+    bst.get(6); // null
+    expect(bst.get(6)).toBeNull();
+    bst.isAVLBalanced(); // true or false
+    expect(bst.isAVLBalanced()).toBe(true);
+    const bfsIDs = bst.BFS();
+    bfsIDs[0] === 11; // true
+    expect(bfsIDs[0]).toBe(11);
+
+    const objBST = new BST<BSTNode<{id: number; keyA: number}>>();
+    objBST.add(11, {id: 11, keyA: 11});
+    objBST.add(3, {id: 3, keyA: 3});
+
+    objBST.addMany(
+      [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5],
+      [
+        {id: 15, keyA: 15},
+        {id: 1, keyA: 1},
+        {id: 8, keyA: 8},
+        {id: 13, keyA: 13},
+        {id: 16, keyA: 16},
+        {id: 2, keyA: 2},
+        {id: 6, keyA: 6},
+        {id: 9, keyA: 9},
+        {id: 12, keyA: 12},
+        {id: 14, keyA: 14},
+        {id: 4, keyA: 4},
+        {id: 7, keyA: 7},
+        {id: 10, keyA: 10},
+        {id: 5, keyA: 5}
+      ]
+    );
+
+    objBST.remove(11);
+
+    const avlTree = new AVLTree();
+    avlTree.addMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
+    avlTree.isAVLBalanced(); // true
+    expect(avlTree.isAVLBalanced()).toBe(true); // true
+    avlTree.remove(10);
+    avlTree.isAVLBalanced(); // true
+    expect(avlTree.isAVLBalanced()).toBe(true); // true
+  });
+});

package/test/unit/data-structures/binary-tree/rb-tree.test.ts

@@ -0,0 +1,43 @@
+// import {RBTree, RBTreeNode} from '../../../../src';
+
+describe('Red-Black Tree Tests', () => {
+  // let tree: RBTree<RBTreeNode<number>>;
+  //
+  // beforeEach(() => {
+  //   tree = new RBTree<RBTreeNode<number>>();
+  // });
+
+  test('Insertion and In-order Traversal', () => {
+    // tree.add(5);
+    // tree.add(3);
+    // tree.add(7);
+    // tree.add(2);
+    // tree.add(4);
+    // tree.add(6);
+    // tree.add(8);
+    //
+    // const inOrderTraversal: number[] = tree.DFS('in')
+    //
+    // expect(inOrderTraversal).toEqual([2, 3, 4, 5, 6, 7, 8]);
+  });
+
+  test('Deletion', () => {
+    // tree.add(5);
+    // tree.add(3);
+    // tree.add(7);
+    // tree.add(2);
+    // tree.add(4);
+    // tree.add(6);
+    // tree.add(8);
+    //
+    // // Delete a node (e.g., 3) and check if it's gone
+    // tree.remove(3);
+    // expect(tree.has(3)).toBe(false);
+    //
+    // // Perform in-order traversal to check if the tree is still balanced
+    // const inOrderTraversal: number[] = tree.DFS('in');
+    //
+    //
+    // expect(inOrderTraversal).toEqual([2, 4, 5, 6, 7, 8]);
+  });
+});

package/test/unit/data-structures/binary-tree/segment-tree.test.ts

@@ -0,0 +1,50 @@
+import {SegmentTree} from '../../../../src';
+
+describe('SegmentTree', () => {
+  let segmentTree: SegmentTree;
+
+  beforeEach(() => {
+    // Create an example SegmentTree for testing
+    const values = [1, 2, 3, 4, 5];
+    segmentTree = new SegmentTree(values);
+  });
+
+  it('should build a valid segment tree', () => {
+    // Check if the root node's sum is correct
+    expect(segmentTree.root?.sum).toBe(15);
+  });
+
+  it('should update a node in the segment tree', () => {
+    // Update a node value
+    segmentTree.updateNode(2, 10);
+
+    // Check if the sum of the root node is correct after the update
+    expect(segmentTree.root?.sum).toBe(22);
+  });
+
+  it('should query sum by range correctly', () => {
+    // Check if the sum within a specific range is correct
+    expect(segmentTree.querySumByRange(1, 3)).toBe(9); // 2 + 3 + 4 = 9
+  });
+
+  it('should handle edge cases for querySumByRange', () => {
+    // Check behavior when the range goes beyond boundaries
+    expect(segmentTree.querySumByRange(0, 4)).toBe(15); // Valid range, should return sum of the specified range
+    expect(segmentTree.querySumByRange(3, 2)).toBe(NaN); // End index is less than start index, should return NaN
+    expect(segmentTree.querySumByRange(0, 10)).toBe(NaN); // Beyond upper bound, should return NaN
+  });
+
+  it('should handle an empty input array', () => {
+    // Check behavior when dealing with an empty input array
+    const emptySegmentTree = new SegmentTree([]);
+    expect(emptySegmentTree.root).toBe(null);
+    expect(emptySegmentTree.querySumByRange(0, 2)).toBe(0); // Sum of an empty array should be 0
+  });
+
+  it('should handle a single-element input array', () => {
+    // Check behavior when the input array contains a single element
+    const singleElementSegmentTree = new SegmentTree([42]);
+    expect(singleElementSegmentTree.root?.sum).toBe(42);
+    expect(singleElementSegmentTree.querySumByRange(0, 0)).toBe(42); // Range covering the only element should return that element's value
+  });
+});