data-structure-typed 1.49.5 → 1.49.6

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

@@ -12,33 +12,23 @@ const cOrderedMap = new OrderedMap<number, number>();
 
 suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
   rbTree.clear();
-  for (let i = 0; i < arr.length; i++) {
-    rbTree.add(arr[i]);
-  }
+  for (let i = 0; i < arr.length; i++) rbTree.add(arr[i]);
 });
 
 if (isCompetitor) {
   suite.add(`CPT ${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
-    for (let i = 0; i < arr.length; i++) {
-      cOrderedMap.setElement(arr[i], arr[i]);
-    }
+    for (let i = 0; i < arr.length; i++) cOrderedMap.setElement(arr[i], arr[i]);
   });
 }
 
 suite
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete randomly`, () => {
     rbTree.clear();
-    for (let i = 0; i < arr.length; i++) {
-      rbTree.add(arr[i]);
-    }
-    for (let i = 0; i < arr.length; i++) {
-      rbTree.delete(arr[i]);
-    }
+    for (let i = 0; i < arr.length; i++) rbTree.add(arr[i]);
+    for (let i = 0; i < arr.length; i++) rbTree.delete(arr[i]);
   })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} getNode`, () => {
-    for (let i = 0; i < arr.length; i++) {
-      rbTree.getNode(arr[i]);
-    }
+    for (let i = 0; i < arr.length; i++) rbTree.getNode(arr[i]);
   });
 
 suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & iterator`, () => {

package/test/performance/data-structures/comparison/comparison.test.ts

@@ -70,75 +70,52 @@ if (isCompetitor) {
       for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
     })
     .add(`CPT OM ${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
-      for (let i = 0; i < arrHundredThousand.length; i++) {
+      for (let i = 0; i < arrHundredThousand.length; i++)
         cOrderedMap.setElement(arrHundredThousand[i], arrHundredThousand[i]);
-      }
     })
     .add(`CPT HM ${TEN_THOUSAND.toLocaleString()} set`, () => {
       const hm = new CHashMap<number, number>();
 
-      for (let i = 0; i < TEN_THOUSAND; i++) {
-        hm.setElement(i, i);
-      }
+      for (let i = 0; i < TEN_THOUSAND; i++) hm.setElement(i, i);
     })
     .add(`CPT HM ${TEN_THOUSAND.toLocaleString()} set & get`, () => {
       const hm = new CHashMap<number, number>();
 
-      for (let i = 0; i < TEN_THOUSAND; i++) {
-        hm.setElement(i, i);
-      }
-      for (let i = 0; i < TEN_THOUSAND; i++) {
-        hm.getElementByKey(i);
-      }
+      for (let i = 0; i < TEN_THOUSAND; i++) hm.setElement(i, i);
+      for (let i = 0; i < TEN_THOUSAND; i++) hm.getElementByKey(i);
     })
     .add(`CPT LL ${MILLION.toLocaleString()} unshift`, () => {
       const list = new CLinkedList<number>();
 
-      for (let i = 0; i < MILLION; i++) {
-        list.pushFront(i);
-      }
+      for (let i = 0; i < MILLION; i++) list.pushFront(i);
     })
     .add(`CPT PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
       const pq = new CPriorityQueue<number>();
 
-      for (let i = 0; i < TEN_THOUSAND; i++) {
-        pq.push(i);
-      }
+      for (let i = 0; i < TEN_THOUSAND; i++) pq.push(i);
 
-      for (let i = 0; i < TEN_THOUSAND; i++) {
-        pq.pop();
-      }
+      for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
     })
     .add(`CPT DQ ${MILLION.toLocaleString()} push`, () => {
       const deque = new CDeque<number>();
-      for (let i = 0; i < MILLION; i++) {
-        deque.pushBack(i);
-      }
+      for (let i = 0; i < MILLION; i++) deque.pushBack(i);
     })
     .add(`CPT Q ${MILLION.toLocaleString()} push`, () => {
       const queue = new CQueue<number>();
 
-      for (let i = 0; i < MILLION; i++) {
-        queue.push(i);
-      }
+      for (let i = 0; i < MILLION; i++) queue.push(i);
     })
     .add(`CPT ST ${MILLION.toLocaleString()} push`, () => {
       const queue = new CStack<number>();
 
-      for (let i = 0; i < MILLION; i++) {
-        queue.push(i);
-      }
+      for (let i = 0; i < MILLION; i++) queue.push(i);
     })
     .add(`CPT ST ${MILLION.toLocaleString()} push & pop`, () => {
       const queue = new CStack<number>();
 
-      for (let i = 0; i < MILLION; i++) {
-        queue.push(i);
-      }
-      for (let i = 0; i < MILLION; i++) {
-        queue.pop();
-      }
+      for (let i = 0; i < MILLION; i++) queue.push(i);
+      for (let i = 0; i < MILLION; i++) queue.pop();
     });
 }
 
-export { suite };
+// export { suite };

package/test/performance/data-structures/graph/directed-graph.test.ts

@@ -9,9 +9,7 @@ const vertexes = getRandomWords(THOUSAND);
 
 suite
   .add(`${THOUSAND.toLocaleString()} addVertex`, () => {
-    for (const v of vertexes) {
-      graph.addVertex(v);
-    }
+    for (const v of vertexes) graph.addVertex(v);
   })
   .add(`${THOUSAND.toLocaleString()} addEdge`, () => {
     for (let i = 0; i < THOUSAND; i++) {
@@ -21,29 +19,20 @@ suite
     }
   })
   .add(`${THOUSAND.toLocaleString()} getVertex`, () => {
-    for (let i = 0; i < THOUSAND; i++) {
-      graph.getVertex(vertexes[getRandomIndex(vertexes)]);
-    }
+    for (let i = 0; i < THOUSAND; i++) graph.getVertex(vertexes[getRandomIndex(vertexes)]);
   })
   .add(`${THOUSAND.toLocaleString()} getEdge`, () => {
-    for (let i = 0; i < THOUSAND; i++) {
+    for (let i = 0; i < THOUSAND; i++)
       graph.getEdge(vertexes[getRandomIndex(vertexes)], vertexes[getRandomIndex(vertexes)]);
-    }
   })
   .add(`tarjan`, () => {
-    // for (let i = 0; i < THOUSAND; i++) {
     graph.tarjan(true);
-    // }
   })
   .add(`tarjan all`, () => {
-    // for (let i = 0; i < THOUSAND; i++) {
     graph.tarjan(true, true, true, true);
-    // }
   })
   .add(`topologicalSort`, () => {
-    // for (let i = 0; i < THOUSAND; i++) {
     graph.topologicalSort('key');
-    // }
   });
 
 export { suite };

package/test/performance/data-structures/hash/hash-map.test.ts

@@ -10,18 +10,14 @@ const { MILLION } = magnitude;
 suite.add(`${MILLION.toLocaleString()} set`, () => {
   const hm = new HashMap<number, number>();
 
-  for (let i = 0; i < MILLION; i++) {
-    hm.set(i, i);
-  }
+  for (let i = 0; i < MILLION; i++) hm.set(i, i);
 });
 
 if (isCompetitor) {
   suite.add(`CPT ${MILLION.toLocaleString()} set`, () => {
     const hm = new CHashMap<number, number>();
 
-    for (let i = 0; i < MILLION; i++) {
-      hm.setElement(i, i);
-    }
+    for (let i = 0; i < MILLION; i++) hm.setElement(i, i);
   });
 }
 
@@ -40,43 +36,30 @@ suite.add(`Native Set ${MILLION.toLocaleString()} add`, () => {
 suite.add(`${MILLION.toLocaleString()} set & get`, () => {
   const hm = new HashMap<number, number>();
 
-  for (let i = 0; i < MILLION; i++) {
-    hm.set(i, i);
-  }
-  for (let i = 0; i < MILLION; i++) {
-    hm.get(i);
-  }
+  for (let i = 0; i < MILLION; i++) hm.set(i, i);
+  for (let i = 0; i < MILLION; i++) hm.get(i);
 });
 
 if (isCompetitor) {
   suite.add(`CPT ${MILLION.toLocaleString()} set & get`, () => {
     const hm = new CHashMap<number, number>();
 
-    for (let i = 0; i < MILLION; i++) {
-      hm.setElement(i, i);
-    }
-    for (let i = 0; i < MILLION; i++) {
-      hm.getElementByKey(i);
-    }
+    for (let i = 0; i < MILLION; i++) hm.setElement(i, i);
+    for (let i = 0; i < MILLION; i++) hm.getElementByKey(i);
   });
 }
 
 suite.add(`Native Map ${MILLION.toLocaleString()} set & get`, () => {
   const hm = new Map<number, number>();
 
-  for (let i = 0; i < MILLION; i++) {
-    hm.set(i, i);
-  }
-  for (let i = 0; i < MILLION; i++) {
-    hm.get(i);
-  }
+  for (let i = 0; i < MILLION; i++) hm.set(i, i);
+  for (let i = 0; i < MILLION; i++) hm.get(i);
 });
 
 suite.add(`Native Set ${MILLION.toLocaleString()} add & has`, () => {
   const hs = new Set<number>();
 
   for (let i = 0; i < MILLION; i++) hs.add(i);
-
   for (let i = 0; i < MILLION; i++) hs.has(i);
 });
 
@@ -88,9 +71,7 @@ suite.add(`${MILLION.toLocaleString()} ObjKey set & get`, () => {
     objKeys.push(obj);
     hm.set(obj, i);
   }
-  for (let i = 0; i < MILLION; i++) {
-    hm.get(objKeys[i]);
-  }
+  for (let i = 0; i < MILLION; i++) hm.get(objKeys[i]);
 });
 
 suite.add(`Native Map ${MILLION.toLocaleString()} ObjKey set & get`, () => {
@@ -101,9 +82,7 @@ suite.add(`Native Map ${MILLION.toLocaleString()} ObjKey set & get`, () => {
     objs.push(obj);
     hm.set(obj, i);
   }
-  for (let i = 0; i < MILLION; i++) {
-    hm.get(objs[i]);
-  }
+  for (let i = 0; i < MILLION; i++) hm.get(objs[i]);
 });
 
 suite.add(`Native Set ${MILLION.toLocaleString()} ObjKey add & has`, () => {
@@ -114,9 +93,7 @@ suite.add(`Native Set ${MILLION.toLocaleString()} ObjKey add & has`, () => {
     objs.push(obj);
     hs.add(obj);
   }
-  for (let i = 0; i < MILLION; i++) {
-    hs.has(objs[i]);
-  }
+  for (let i = 0; i < MILLION; i++) hs.has(objs[i]);
 });
 
 export { suite };

package/test/performance/data-structures/heap/heap.test.ts

@@ -9,31 +9,18 @@ suite
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
     const heap = new Heap<number>([], { comparator: (a, b) => b - a });
 
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      heap.add(i);
-    }
-
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      heap.poll();
-    }
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.poll();
   })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & dfs`, () => {
     const heap = new Heap<number>([], { comparator: (a, b) => b - a });
-
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      heap.add(i);
-    }
-
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(i);
     heap.dfs();
   })
   .add(`${TEN_THOUSAND.toLocaleString()} fib add & pop`, () => {
     const fbHeap = new FibonacciHeap<number>();
-    for (let i = 1; i <= TEN_THOUSAND; i++) {
-      fbHeap.push(i);
-    }
-    for (let i = 1; i <= TEN_THOUSAND; i++) {
-      fbHeap.pop();
-    }
+    for (let i = 1; i <= TEN_THOUSAND; i++) fbHeap.push(i);
+    for (let i = 1; i <= TEN_THOUSAND; i++) fbHeap.pop();
   });
 
 export { suite };

package/test/performance/data-structures/linked-list/doubly-linked-list.test.ts

@@ -40,7 +40,6 @@ suite
     const list = new DoublyLinkedList<number>();
 
     for (let i = 0; i < MILLION; i++) list.unshift(i);
-
     for (let i = 0; i < MILLION; i++) list.shift();
   })
   .add(`${MILLION.toLocaleString()} addBefore`, () => {

package/test/performance/data-structures/linked-list/singly-linked-list.test.ts

@@ -10,14 +10,12 @@ suite
     const list = new SinglyLinkedList<number>();
 
     for (let i = 0; i < MILLION; i++) list.push(i);
-
     for (let i = 0; i < MILLION; i++) list.shift();
   })
   .add(`${TEN_THOUSAND.toLocaleString()} push & pop`, () => {
     const list = new SinglyLinkedList<number>();
 
     for (let i = 0; i < TEN_THOUSAND; i++) list.push(i);
-
     for (let i = 0; i < TEN_THOUSAND; i++) list.pop();
   })
   .add(`${TEN_THOUSAND.toLocaleString()} addBefore`, () => {

package/test/performance/data-structures/priority-queue/max-priority-queue.test.ts

@@ -11,9 +11,7 @@ suite.add(`${TEN_THOUSAND.toLocaleString()} refill & poll`, () => {
   );
   const maxPQ = new MaxPriorityQueue<number>();
   maxPQ.refill(nodes);
-  while (maxPQ.size > 0) {
-    maxPQ.poll();
-  }
+  while (maxPQ.size > 0) maxPQ.poll();
 });
 
-export { suite };
+// export { suite };

package/test/performance/data-structures/priority-queue/priority-queue.test.ts

@@ -10,25 +10,15 @@ const { HUNDRED_THOUSAND } = magnitude;
 suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
   const pq = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
 
-  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-    pq.add(i);
-  }
-
-  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-    pq.poll();
-  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.add(i);
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.poll();
 });
 if (isCompetitor) {
   suite.add(`CPT ${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
     const pq = new CPriorityQueue<number>();
 
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      pq.push(i);
-    }
-
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      pq.pop();
-    }
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.push(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.pop();
   });
 }
 

package/test/performance/data-structures/queue/queue.test.ts

@@ -10,50 +10,33 @@ const { MILLION, HUNDRED_THOUSAND } = magnitude;
 suite.add(`${MILLION.toLocaleString()} push`, () => {
   const queue = new Queue<number>();
 
-  for (let i = 0; i < MILLION; i++) {
-    queue.push(i);
-  }
+  for (let i = 0; i < MILLION; i++) queue.push(i);
 });
 if (isCompetitor) {
   suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const queue = new CQueue<number>();
 
-    for (let i = 0; i < MILLION; i++) {
-      queue.push(i);
-    }
+    for (let i = 0; i < MILLION; i++) queue.push(i);
   });
 }
 suite.add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
   const queue = new Queue<number>();
 
-  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-    queue.push(i);
-  }
-  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-    queue.shift();
-  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) queue.push(i);
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) queue.shift();
 });
 suite
   .add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
     const arr = new Array<number>();
 
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      arr.push(i);
-    }
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      arr.shift();
-    }
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.push(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.shift();
   })
   .add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} push & pop`, () => {
     const arr = new Array<number>();
 
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      arr.push(i);
-    }
-
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      arr.pop();
-    }
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.push(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.pop();
   });
 
 export { suite };

package/test/performance/data-structures/stack/stack.test.ts

@@ -10,39 +10,27 @@ const { MILLION } = magnitude;
 suite.add(`${MILLION.toLocaleString()} push`, () => {
   const stack = new Stack<number>();
 
-  for (let i = 0; i < MILLION; i++) {
-    stack.push(i);
-  }
+  for (let i = 0; i < MILLION; i++) stack.push(i);
 });
 if (isCompetitor) {
   suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const queue = new CStack<number>();
 
-    for (let i = 0; i < MILLION; i++) {
-      queue.push(i);
-    }
+    for (let i = 0; i < MILLION; i++) queue.push(i);
   });
 }
 suite.add(`${MILLION.toLocaleString()} push & pop`, () => {
   const queue = new Stack<number>();
 
-  for (let i = 0; i < MILLION; i++) {
-    queue.push(i);
-  }
-  for (let i = 0; i < MILLION; i++) {
-    queue.pop();
-  }
+  for (let i = 0; i < MILLION; i++) queue.push(i);
+  for (let i = 0; i < MILLION; i++) queue.pop();
 });
 if (isCompetitor) {
   suite.add(`CPT ${MILLION.toLocaleString()} push & pop`, () => {
     const queue = new CStack<number>();
 
-    for (let i = 0; i < MILLION; i++) {
-      queue.push(i);
-    }
-    for (let i = 0; i < MILLION; i++) {
-      queue.pop();
-    }
+    for (let i = 0; i < MILLION; i++) queue.push(i);
+    for (let i = 0; i < MILLION; i++) queue.pop();
   });
 }
 

package/test/performance/data-structures/trie/trie.test.ts

@@ -9,14 +9,10 @@ const randomWords = getRandomWords(HUNDRED_THOUSAND, false);
 
 suite
   .add(`${HUNDRED_THOUSAND.toLocaleString()} push`, () => {
-    for (let i = 0; i < randomWords.length; i++) {
-      trie.add(randomWords[i]);
-    }
+    for (let i = 0; i < randomWords.length; i++) trie.add(randomWords[i]);
   })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} getWords`, () => {
-    for (let i = 0; i < randomWords.length; i++) {
-      trie.getWords(randomWords[i]);
-    }
+    for (let i = 0; i < randomWords.length; i++) trie.getWords(randomWords[i]);
   });
 
 export { suite };

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

@@ -106,7 +106,8 @@ describe('BinaryTree', () => {
   it('should delete nodes', () => {
     expect(tree.getHeight(tree.root, IterationType.ITERATIVE)).toBe(-1);
     expect(tree.getMinHeight()).toBe(-1);
-    const node1 = tree.add(1);
+    const node1 = tree.createNode(1);
+    tree.add(node1);
     expect(tree.size).toBe(1);
 
     const leftChild = new BinaryTreeNode<number>(2);
@@ -224,15 +225,15 @@ describe('BinaryTree', () => {
       new BinaryTreeNode(4, 4)
     ]);
 
-    expect(tree.isSubtreeBST(tree.getNode(4), IterationType.RECURSIVE)).toBe(true);
-    expect(tree.isSubtreeBST(tree.getNode(4), IterationType.ITERATIVE)).toBe(true);
+    expect(tree.isBST(tree.getNode(4), IterationType.RECURSIVE)).toBe(true);
+    expect(tree.isBST(tree.getNode(4), IterationType.ITERATIVE)).toBe(true);
   });
 
   it('should isSubtreeBST', () => {
     tree.addMany([4, 2, 6, 1, 3, 5, 7, 4]);
 
-    expect(tree.isSubtreeBST(tree.getNode(4), IterationType.RECURSIVE)).toBe(true);
-    expect(tree.isSubtreeBST(tree.getNode(4), IterationType.ITERATIVE)).toBe(true);
+    expect(tree.isBST(tree.getNode(4), IterationType.RECURSIVE)).toBe(true);
+    expect(tree.isBST(tree.getNode(4), IterationType.ITERATIVE)).toBe(true);
     expect(tree.getNodes(2, undefined, false, null)).toEqual([]);
     expect(tree.getNodes(tree.getNodeByKey(2), undefined, false, tree.root)).toEqual([tree.getNodeByKey(2)]);
   });

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

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BST, BSTNode, CP, IterationType } from '../../../../src';
+import { BinaryTreeNode, BST, BSTNode, BSTVariant, CP, IterationType } from '../../../../src';
 import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
@@ -47,6 +47,8 @@ describe('BST operations test', () => {
     const leftMost = bst.getLeftMost();
     expect(leftMost?.key).toBe(1);
 
+    expect(bst.isBST()).toBe(true);
+
     const node15 = bst.getNode(15);
     const minNodeBySpecificNode = node15 && bst.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
@@ -795,6 +797,20 @@ describe('BST operations test recursively', () => {
   });
 });
 
+describe('BST isBST', function () {
+  test('isBST', () => {
+    const bst = new BST<number, number>();
+    bst.addMany([1, 2, 3, 9, 8, 5, 6, 7, 4]);
+    expect(bst.isBST()).toBe(true);
+  });
+
+  test('isBST when variant is Max', () => {
+    const bst = new BST<number, number>([1, 2, 3, 9, 8, 5, 6, 7, 4], { variant: BSTVariant.INVERSE });
+    bst.addMany([1, 2, 3, 9, 8, 5, 6, 7, 4]);
+    expect(bst.isBST()).toBe(true);
+  });
+});
+
 describe('BST Performance test', function () {
   const bst = new BST<number, number>();
   const inputSize = 10000; // Adjust input sizes as needed