data-structure-typed 1.41.0 → 1.41.2

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

@@ -1,5 +1,8 @@
-import { RedBlackTree, RBTreeNode } from '../../../../src';
-import {getRandomInt} from "../../../utils";
+import {RBTNColor, RBTreeNode, RedBlackTree, NIL} from '../../../../src';
+import {getRandomInt} from '../../../utils';
+import {isDebugTest} from '../../../config';
+
+const isDebug = isDebugTest;
 
 describe('RedBlackTree', () => {
   let tree: RedBlackTree;
@@ -17,7 +20,7 @@ describe('RedBlackTree', () => {
       expect(tree.getNode(10)).toBeInstanceOf(RBTreeNode);
       expect(tree.getNode(20)).toBeInstanceOf(RBTreeNode);
       expect(tree.getNode(5)).toBeInstanceOf(RBTreeNode);
-      expect(tree.getNode(15)).toBe(tree.NIL);
+      expect(tree.getNode(15)).toBe(null);
     });
 
     test('should insert and find nodes with negative keys', () => {
@@ -36,7 +39,7 @@ describe('RedBlackTree', () => {
       tree.insert(5);
       tree.delete(20);
 
-      expect(tree.getNode(20)).toBe(tree.NIL);
+      expect(tree.getNode(20)).toBe(null);
     });
 
     test('should handle deleting a non-existent node', () => {
@@ -45,7 +48,7 @@ describe('RedBlackTree', () => {
       tree.insert(5);
       tree.delete(15);
 
-      expect(tree.getNode(15)).toBe(tree.NIL);
+      expect(tree.getNode(15)).toBe(null);
     });
   });
 
@@ -63,7 +66,7 @@ describe('RedBlackTree', () => {
 
     test('should handle an empty tree', () => {
       const minNode = tree.getLeftMost(tree.root);
-      expect(minNode).toBe(tree.NIL);
+      expect(minNode).toBe(NIL);
     });
   });
 
@@ -81,7 +84,7 @@ describe('RedBlackTree', () => {
 
     test('should handle an empty tree', () => {
       const maxNode = tree.getRightMost(tree.root);
-      expect(maxNode).toBe(tree.NIL);
+      expect(maxNode).toBe(NIL);
     });
   });
 
@@ -105,7 +108,7 @@ describe('RedBlackTree', () => {
 
       const node = tree.getNode(10);
       const successorNode = tree.getSuccessor(node);
-      // TODO not sure if it should be null or tree.NIL
+      // TODO not sure if it should be null or NIL
       expect(successorNode).toBe(null);
     });
   });
@@ -130,13 +133,12 @@ describe('RedBlackTree', () => {
 
       const node = tree.getNode(20);
       const predecessorNode = tree.getPredecessor(node);
-      // TODO not sure if it should be tree.NIL or something else.
+      // TODO not sure if it should be NIL or something else.
       expect(predecessorNode).toBe(tree.getNode(10));
     });
   });
 });
 
-
 describe('RedBlackTree', () => {
   let tree: RedBlackTree;
 
@@ -158,7 +160,7 @@ describe('RedBlackTree', () => {
     tree.insert(20);
     tree.insert(5);
     tree.delete(20);
-    expect(tree.getNode(20)).toBe(tree.NIL);
+    expect(tree.getNode(20)).toBe(null);
   });
 
   it('should get the successor of a node', () => {
@@ -199,25 +201,158 @@ describe('RedBlackTree', () => {
     expect(node.right.key).toBe(25);
   });
 
-  it('should fix the tree after deletion', () => {
+  it('should all node attributes fully conform to the red-black tree standards.', () => {
     tree.insert(10);
     tree.insert(20);
     tree.insert(5);
     tree.insert(15);
-    tree.delete(15);
-    // Verify that the tree is still valid
-    // You can add assertions to check the Red-Black Tree properties
+    tree.insert(21);
+    tree.insert(6);
+    tree.insert(2);
+
+    let node10F = tree.getNode(10);
+    let node20F = tree.getNode(20);
+    let node5F = tree.getNode(5);
+    let node15F = tree.getNode(15);
+    let node21F = tree.getNode(21);
+    let node6F = tree.getNode(6);
+    let node2F = tree.getNode(2);
+    expect(node10F.key).toBe(10);
+    expect(node10F.color).toBe(RBTNColor.BLACK);
+    expect(node10F.left).toBe(node5F);
+    expect(node10F.right).toBe(node20F);
+    expect(node10F.parent).toBe(null);
+    expect(node20F.key).toBe(20);
+    expect(node20F.color).toBe(RBTNColor.BLACK);
+    expect(node20F.left).toBe(node15F);
+    expect(node20F.right).toBe(node21F);
+    expect(node20F.parent).toBe(node10F);
+    expect(node5F.key).toBe(5);
+    expect(node5F.color).toBe(RBTNColor.BLACK);
+    expect(node5F.left).toBe(node2F);
+    expect(node5F.right).toBe(node6F);
+    expect(node5F.parent).toBe(node10F);
+    expect(node15F.key).toBe(15);
+    expect(node15F.color).toBe(RBTNColor.RED);
+    expect(node15F.left).toBe(NIL);
+    expect(node15F.right).toBe(NIL);
+    expect(node15F.parent).toBe(node20F);
+    expect(node21F.key).toBe(21);
+    expect(node21F.color).toBe(RBTNColor.RED);
+    expect(node21F.left).toBe(NIL);
+    expect(node21F.right).toBe(NIL);
+    expect(node21F.parent).toBe(node20F);
+    expect(node6F.key).toBe(6);
+    expect(node6F.color).toBe(RBTNColor.RED);
+    expect(node6F.left).toBe(NIL);
+    expect(node6F.right).toBe(NIL);
+    expect(node6F.parent).toBe(node5F);
+    expect(node2F.key).toBe(2);
+    expect(node2F.color).toBe(RBTNColor.RED);
+    expect(node2F.left).toBe(NIL);
+    expect(node2F.right).toBe(NIL);
+    expect(node2F.parent).toBe(node5F);
+    expect(node15F.key).toBe(15);
+    expect(node15F.color).toBe(RBTNColor.RED);
+    expect(node15F.left).toBe(NIL);
+    expect(node15F.right).toBe(NIL);
+    expect(node15F.parent).toBe(node20F);
+    tree.delete(5);
+    node10F = tree.getNode(10);
+    node20F = tree.getNode(20);
+    node5F = tree.getNode(5);
+    node15F = tree.getNode(15);
+    node21F = tree.getNode(21);
+    node6F = tree.getNode(6);
+    node2F = tree.getNode(2);
+    expect(node10F.key).toBe(10);
+    expect(node10F.color).toBe(RBTNColor.BLACK);
+    expect(node10F.left).toBe(node6F);
+    expect(node10F.right).toBe(node20F);
+    expect(node10F.parent).toBe(null);
+    expect(node20F.key).toBe(20);
+    expect(node20F.color).toBe(RBTNColor.BLACK);
+    expect(node20F.left).toBe(node15F);
+    expect(node20F.right).toBe(node21F);
+    expect(node20F.parent).toBe(node10F);
+    expect(node5F).toBe(null);
+    expect(node15F.key).toBe(15);
+    expect(node15F.color).toBe(RBTNColor.RED);
+    expect(node15F.left).toBe(NIL);
+    expect(node15F.right).toBe(NIL);
+    expect(node15F.parent).toBe(node20F);
+    expect(node21F.key).toBe(21);
+    expect(node21F.color).toBe(RBTNColor.RED);
+    expect(node21F.left).toBe(NIL);
+    expect(node21F.right).toBe(NIL);
+    expect(node21F.parent).toBe(node20F);
+    expect(node6F.key).toBe(6);
+    expect(node6F.color).toBe(RBTNColor.BLACK);
+    expect(node6F.left).toBe(node2F);
+    expect(node6F.right).toBe(NIL);
+    expect(node6F.parent).toBe(node10F);
+    expect(node2F.key).toBe(2);
+    expect(node2F.color).toBe(RBTNColor.RED);
+    expect(node2F.left).toBe(NIL);
+    expect(node2F.right).toBe(NIL);
+    expect(node2F.parent).toBe(node6F);
+    expect(node15F.key).toBe(15);
+    expect(node15F.color).toBe(RBTNColor.RED);
+    expect(node15F.left).toBe(NIL);
+    expect(node15F.right).toBe(NIL);
+    expect(node15F.parent).toBe(node20F);
+    tree.delete(20);
+    node10F = tree.getNode(10);
+    node20F = tree.getNode(20);
+    node5F = tree.getNode(5);
+    node15F = tree.getNode(15);
+    node21F = tree.getNode(21);
+    node6F = tree.getNode(6);
+    node2F = tree.getNode(2);
+    expect(node10F.key).toBe(10);
+    expect(node10F.color).toBe(RBTNColor.BLACK);
+    expect(node10F.left).toBe(node6F);
+    expect(node10F.right).toBe(node21F);
+    expect(node10F.parent).toBe(null);
+    expect(node20F).toBe(null);
+    expect(node5F).toBe(null);
+    expect(node15F.key).toBe(15);
+    expect(node15F.color).toBe(RBTNColor.RED);
+    expect(node15F.left).toBe(NIL);
+    expect(node15F.right).toBe(NIL);
+    expect(node15F.parent).toBe(node21F);
+    expect(node21F.key).toBe(21);
+    expect(node21F.color).toBe(RBTNColor.BLACK);
+    expect(node21F.left).toBe(node15F);
+    expect(node21F.right).toBe(NIL);
+    expect(node21F.parent).toBe(node10F);
+    expect(node6F.key).toBe(6);
+    expect(node6F.color).toBe(RBTNColor.BLACK);
+    expect(node6F.left).toBe(node2F);
+    expect(node6F.right).toBe(NIL);
+    expect(node6F.parent).toBe(node10F);
+    expect(node2F.key).toBe(2);
+    expect(node2F.color).toBe(RBTNColor.RED);
+    expect(node2F.left).toBe(NIL);
+    expect(node2F.right).toBe(NIL);
+    expect(node2F.parent).toBe(node6F);
+    expect(node15F.key).toBe(15);
+    expect(node15F.color).toBe(RBTNColor.RED);
+    expect(node15F.left).toBe(NIL);
+    expect(node15F.right).toBe(NIL);
+    expect(node15F.parent).toBe(node21F);
   });
 
   it('should fix the tree after insertion', () => {
-    for (let i = 0; i < 1000; i++) {
-      tree.insert(getRandomInt(-100, 1000));
-      tree.delete(getRandomInt(-100, 1000));
-    }
     tree.insert(1);
     tree.insert(2);
     tree.insert(5);
     tree.insert(15);
+    const node15F = tree.getNode(15);
+    expect(node15F.left).toBe(NIL);
+    expect(node15F.right).toBe(NIL);
+    expect(node15F.parent).toBe(tree.getNode(5));
+
     tree.insert(25);
     tree.insert(10);
     tree.insert(8);
@@ -229,14 +364,72 @@ describe('RedBlackTree', () => {
     tree.insert(50);
     tree.insert(155);
     tree.insert(225);
+    const node225F = tree.getNode(225);
+    expect(node225F.left).toBe(NIL);
+    expect(node225F.right).toBe(NIL);
+    expect(node225F.parent.key).toBe(155);
     tree.insert(7);
+
+    const node15S = tree.getNode(15);
+    expect(node15S.left.key).toBe(8);
+    expect(node15S.right.key).toBe(28);
+    expect(node15S).toBe(tree.root);
+    expect(node15S.parent).toBe(null);
     tree.delete(15);
+    expect(tree.root.key).toBe(22);
+    expect(tree.root.parent).toBe(null);
+
+    const node15T = tree.getNode(15);
+    expect(node15T).toBe(null);
+
     tree.insert(23);
     tree.insert(33);
     tree.insert(15);
 
+    const nodeLM = tree.getLeftMost();
+    expect(nodeLM.key).toBe(1);
+
+    const node50 = tree.getNode(50);
+    expect(node50.key).toBe(50);
+    expect(node50.left.key).toBe(33);
+    expect(node50.right).toBe(NIL);
+    const node15Fo = tree.getNode(15);
+
+    expect(node15Fo.key).toBe(15);
+    expect(node15Fo.left).toBe(NIL);
+    const node225S = tree.getNode(225);
+    expect(node225S.left).toBe(NIL);
+    expect(node225S.right).toBe(NIL);
+    expect(node225S.parent.key).toBe(155);
+    expect(tree.getNode(0)).toBe(null);
+    tree.insert(1);
+    tree.insert(2);
+    tree.insert(3);
+    tree.insert(4);
+    tree.insert(5);
+    tree.insert(6);
+    tree.insert(7);
+    tree.insert(8);
+    tree.insert(9);
+    tree.insert(10);
+    tree.insert(11);
+    tree.insert(12);
+    tree.insert(13);
+    tree.insert(14);
+    tree.insert(15);
+    tree.insert(16);
+    tree.insert(17);
+    tree.insert(18);
+    tree.insert(19);
+    tree.insert(110);
+
+    isDebug && tree.print();
+  });
 
-    // Verify that the tree is still a valid Red-Black Tree
-    // You can add assertions to check the Red-Black Tree properties
+  it('should fix the tree after insertion and deletion', () => {
+    for (let i = 0; i < 1000; i++) {
+      tree.insert(getRandomInt(-100, 1000));
+      tree.delete(getRandomInt(-100, 1000));
+    }
   });
 });

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

@@ -23,10 +23,10 @@ describe('TreeMultiset operations test', () => {
 
     expect(treeMultiset.getHeight(6)).toBe(3);
     expect(treeMultiset.getDepth(6)).toBe(1);
-    const nodeId10 = treeMultiset.get(10);
+    const nodeId10 = treeMultiset.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = treeMultiset.get(9, node => node.value);
+    const nodeVal9 = treeMultiset.getNode(9, node => node.value);
     expect(nodeVal9?.key).toBe(9);
 
     const nodesByCount1 = treeMultiset.getNodes(1, node => node.count);
@@ -37,7 +37,7 @@ describe('TreeMultiset operations test', () => {
     const leftMost = treeMultiset.getLeftMost();
     expect(leftMost?.key).toBe(1);
 
-    const node15 = treeMultiset.get(15);
+    const node15 = treeMultiset.getNode(15);
     const minNodeBySpecificNode = node15 && treeMultiset.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
@@ -53,7 +53,7 @@ describe('TreeMultiset operations test', () => {
       const subTreeAdd = treeMultiset.subTreeTraverse((node: TreeMultisetNode<number>) => (node.count += 1), 15);
       expect(subTreeAdd);
     }
-    const node11 = treeMultiset.get(11);
+    const node11 = treeMultiset.getNode(11);
     expect(node11 instanceof TreeMultisetNode);
     if (node11 instanceof TreeMultisetNode) {
       const allGreaterNodesAdded = treeMultiset.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
@@ -263,10 +263,10 @@ describe('TreeMultiset operations test recursively', () => {
 
     expect(treeMultiset.getHeight(6)).toBe(3);
     expect(treeMultiset.getDepth(6)).toBe(1);
-    const nodeId10 = treeMultiset.get(10);
+    const nodeId10 = treeMultiset.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = treeMultiset.get(9, node => node.value);
+    const nodeVal9 = treeMultiset.getNode(9, node => node.value);
     expect(nodeVal9?.key).toBe(9);
 
     const nodesByCount1 = treeMultiset.getNodes(1, node => node.count);
@@ -277,7 +277,7 @@ describe('TreeMultiset operations test recursively', () => {
     const leftMost = treeMultiset.getLeftMost();
     expect(leftMost?.key).toBe(1);
 
-    const node15 = treeMultiset.get(15);
+    const node15 = treeMultiset.getNode(15);
     const minNodeBySpecificNode = node15 && treeMultiset.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
@@ -293,7 +293,7 @@ describe('TreeMultiset operations test recursively', () => {
       const subTreeAdd = treeMultiset.subTreeTraverse((node: TreeMultisetNode<number>) => (node.count += 1), 15);
       expect(subTreeAdd);
     }
-    const node11 = treeMultiset.get(11);
+    const node11 = treeMultiset.getNode(11);
     expect(node11 instanceof TreeMultisetNode);
     if (node11 instanceof TreeMultisetNode) {
       const allGreaterNodesAdded = treeMultiset.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);

package/test/utils/big-o.js

@@ -23,9 +23,11 @@ exports.bigO = {
   CUBED: Math.pow(exports.magnitude.SQUARED, 3) / 1000,
   FACTORIAL: 10000
 };
+
 function findPotentialN(input) {
   var longestArray = [];
   var mostProperties = {};
+
   function recurse(obj) {
     if (Array.isArray(obj)) {
       if (obj.length > longestArray.length) {
@@ -41,6 +43,7 @@ function findPotentialN(input) {
       });
     }
   }
+
   if (Array.isArray(input)) {
     input.forEach(function (item) {
       recurse(item);
@@ -51,6 +54,7 @@ function findPotentialN(input) {
   // return [longestArray, mostProperties] : [any[], { [key: string]: any }];
   return Math.max(longestArray.length, Object.keys(mostProperties).length);
 }
+
 function linearRegression(x, y) {
   var n = x.length;
   var sumX = x.reduce(function (acc, val) {
@@ -87,6 +91,7 @@ function linearRegression(x, y) {
   var rSquared = 1 - totalVariation / explainedVariation;
   return {slope: slope, intercept: intercept, rSquared: rSquared};
 }
+
 function estimateBigO(runtimes, dataSizes) {
   // Make sure the input runtimes and data sizes have the same length
   if (runtimes.length !== dataSizes.length) {
@@ -137,7 +142,9 @@ function estimateBigO(runtimes, dataSizes) {
     return complexities.join(' or ');
   }
 }
+
 var methodLogs = new Map();
+
 function logBigOMetricsWrap(fn, args, fnName) {
   var startTime = performance.now();
   var result = fn(args);
@@ -169,7 +176,9 @@ function logBigOMetricsWrap(fn, args, fnName) {
   }
   return result;
 }
+
 exports.logBigOMetricsWrap = logBigOMetricsWrap;
+
 function logBigOMetrics(target, propertyKey, descriptor) {
   var originalMethod = descriptor.value;
   descriptor.value = function () {
@@ -209,4 +218,5 @@ function logBigOMetrics(target, propertyKey, descriptor) {
   };
   return descriptor;
 }
+
 exports.logBigOMetrics = logBigOMetrics;