data-structure-typed 1.48.5 → 1.48.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "data-structure-typed",
-  "version": "1.48.5",
-  "description": "Data Structures of Javascript & TypeScript. Heap, Binary Tree, RedBlack Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack.",
+  "version": "1.48.7",
+  "description": "Data Structures of Javascript & TypeScript. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
   "types": "dist/mjs/index.d.ts",

package/src/data-structures/binary-tree/avl-tree.ts

@@ -99,7 +99,7 @@ export class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeN
   /**
    * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
    * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
-   * 
+   *
    * The function overrides the add method of a binary tree node and balances the tree after inserting
    * a new node.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an

package/src/data-structures/binary-tree/binary-tree.ts

@@ -235,7 +235,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   /**
    * Time Complexity O(log n) - O(n)
    * Space Complexity O(1)
-   * 
+   *
    * The `add` function adds a new node to a binary tree, either by creating a new node or replacing an
    * existing node with the same key.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
@@ -248,6 +248,9 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
     if (newNode === undefined) return;
 
+    // TODO There are still some problems with the way duplicate nodes are handled
+    if (newNode !== null && this.has(newNode.key)) return undefined;
+
     const _bfs = (root: N, newNode: N | null): N | undefined | null => {
       const queue = new Queue<N>([root]);
       while (queue.size > 0) {
@@ -288,38 +291,46 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * Time Complexity: O(k log n) - O(k * n)
    * Space Complexity: O(1)
    *
-   * The function `addMany` takes in an iterable of `BTNodeExemplar` objects, adds each object to the
-   * current instance, and returns an array of the inserted nodes.
-   * @param nodes - The `nodes` parameter is an iterable (such as an array or a set) of
-   * `BTNodeExemplar<K, V,N>` objects.
-   * @returns The function `addMany` returns an array of values, where each value is either of type
-   * `N`, `null`, or `undefined`.
-   */
-  addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>): (N | null | undefined)[] {
+   * The `addMany` function takes in a collection of nodes and an optional collection of values, and
+   * adds each node with its corresponding value to the data structure.
+   * @param nodes - An iterable collection of BTNodeExemplar objects.
+   * @param [values] - An optional iterable of values that will be assigned to each node being added.
+   * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+   */
+  addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[] {
     // TODO not sure addMany not be run multi times
     const inserted: (N | null | undefined)[] = [];
+
+    let valuesIterator: Iterator<V | undefined> | undefined;
+    if (values) {
+      valuesIterator = values[Symbol.iterator]();
+    }
+
     for (const kne of nodes) {
-      inserted.push(this.add(kne));
+      let value: V | undefined | null = undefined;
+
+      if (valuesIterator) {
+        const valueResult = valuesIterator.next();
+        if (!valueResult.done) {
+          value = valueResult.value;
+        }
+      }
+
+      inserted.push(this.add(kne, value));
     }
+
     return inserted;
   }
 
-  /**
-   * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
-   * Space Complexity: O(1)
-   */
 
   /**
    * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
    * Space Complexity: O(1)
-   *
-   * The `refill` function clears the current collection and adds new nodes, keys, or entries to it.
-   * @param nodesOrKeysOrEntries - The parameter `nodesOrKeysOrEntries` is an iterable object that can
-   * contain either `BTNodeExemplar` objects, keys, or entries.
    */
-  refill(nodesOrKeysOrEntries: Iterable<BTNodeExemplar<K, V, N>>): void {
+
+  refill(nodesOrKeysOrEntries: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>): void {
     this.clear();
-    this.addMany(nodesOrKeysOrEntries);
+    this.addMany(nodesOrKeysOrEntries, values);
   }
 
   /**

package/src/data-structures/binary-tree/bst.ts

@@ -192,7 +192,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
   /**
    * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
    * Space Complexity: O(1) - Constant space is used.
-   * 
+   *
    * The `add` function adds a new node to a binary tree, updating the value if the key already exists
    * or inserting a new node if the key is unique.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can accept three types of values:
@@ -256,31 +256,45 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
    * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
    * Space Complexity: O(k) - Additional space is required for the sorted array.
    *
-   * The `addMany` function in TypeScript adds multiple nodes to a binary tree, either in a balanced or
-   * unbalanced manner, and returns an array of the inserted nodes.
-   * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries to be added to the
-   * binary tree.
-   * @param [isBalanceAdd=true] - A boolean flag indicating whether the tree should be balanced after
-   * adding the nodes. The default value is true.
+   * The `addMany` function in TypeScript adds multiple keys or nodes to a binary tree, optionally
+   * balancing the tree after each addition.
+   * @param keysOrNodesOrEntries - An iterable containing the keys, nodes, or entries to be added to
+   * the binary tree.
+   * @param [values] - An optional iterable of values to be associated with the keys or nodes being
+   * added. If provided, the values will be assigned to the corresponding keys or nodes in the same
+   * order. If not provided, undefined will be assigned as the value for each key or node.
+   * @param [isBalanceAdd=true] - A boolean flag indicating whether the add operation should be
+   * balanced or not. If set to true, the add operation will be balanced using a binary search tree
+   * algorithm. If set to false, the add operation will not be balanced and the elements will be added
+   * in the order they appear in the input.
    * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-   * type of iteration to use when adding multiple keys or nodes to the binary tree. It has a default
-   * value of `this.iterationType`, which means it will use the iteration type specified by the binary
-   * tree instance.
-   * @returns The `addMany` function returns an array of `N` or `undefined` values.
+   * type of iteration to use when adding multiple keys or nodes. It has a default value of
+   * `this.iterationType`, which suggests that it is a property of the current object.
+   * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
    */
   override addMany(
     keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>,
+    values?: Iterable<V | undefined>,
     isBalanceAdd = true,
     iterationType = this.iterationType
   ): (N | undefined)[] {
-    const inserted: (N | undefined)[] = []
+    const inserted: (N | undefined)[] = [];
+
+    let valuesIterator: Iterator<V | undefined> | undefined;
+
+    if (values) {
+      valuesIterator = values[Symbol.iterator]();
+    }
+
     if (!isBalanceAdd) {
       for (const kve of keysOrNodesOrEntries) {
-        const nn = this.add(kve)
+        const value = valuesIterator?.next().value;
+        const nn = this.add(kve, value);
         inserted.push(nn);
       }
       return inserted;
     }
+
     const realBTNExemplars: BTNodePureExemplar<K, V, N>[] = [];
 
     const isRealBTNExemplar = (kve: BTNodeExemplar<K, V, N>): kve is BTNodePureExemplar<K, V, N> => {
@@ -292,22 +306,20 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
       isRealBTNExemplar(kve) && realBTNExemplars.push(kve);
     }
 
-    // TODO this addMany function is inefficient, it should be optimized
     let sorted: BTNodePureExemplar<K, V, N>[] = [];
 
     sorted = realBTNExemplars.sort((a, b) => {
       let aR: number, bR: number;
-      if (this.isEntry(a)) aR = this.extractor(a[0])
-      else if (this.isRealNode(a)) aR = this.extractor(a.key)
+      if (this.isEntry(a)) aR = this.extractor(a[0]);
+      else if (this.isRealNode(a)) aR = this.extractor(a.key);
       else aR = this.extractor(a);
 
-      if (this.isEntry(b)) bR = this.extractor(b[0])
-      else if (this.isRealNode(b)) bR = this.extractor(b.key)
+      if (this.isEntry(b)) bR = this.extractor(b[0]);
+      else if (this.isRealNode(b)) bR = this.extractor(b.key);
       else bR = this.extractor(b);
 
       return aR - bR;
-    })
-
+    });
 
     const _dfs = (arr: BTNodePureExemplar<K, V, N>[]) => {
       if (arr.length === 0) return;
@@ -318,6 +330,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
       _dfs(arr.slice(0, mid));
       _dfs(arr.slice(mid + 1));
     };
+
     const _iterate = () => {
       const n = sorted.length;
       const stack: [[number, number]] = [[0, n - 1]];
@@ -335,6 +348,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
         }
       }
     };
+
     if (iterationType === IterationType.RECURSIVE) {
       _dfs(sorted);
     } else {
@@ -344,31 +358,45 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
     return inserted;
   }
 
-  // /**
-  //  * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
-  //  * Space Complexity: O(n) - Additional space is required for the sorted array.
-  //  */
-  //
-  // /**
-  //  * Time Complexity: O(log n) - Average case for a balanced tree.
-  //  * Space Complexity: O(1) - Constant space is used.
-  //  *
-  //  * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
-  //  * leftmost node if the comparison result is greater than.
-  //  * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
-  //  * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
-  //  * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
-  //  * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-  //  * be performed. It can have one of the following values:
-  //  * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
-  //  * the key of the leftmost node if the comparison result is greater than, and the key of the
-  //  * rightmost node otherwise. If no node is found, it returns 0.
-  //  */
-  // lastKey(beginRoot: BSTNodeKeyOrNode<K,N> = this.root, iterationType = this.iterationType): K {
-  //   if (this._compare(0, 1) === CP.lt) return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
-  //   else if (this._compare(0, 1) === CP.gt) return this.getLeftMost(beginRoot, iterationType)?.key ?? 0;
-  //   else return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
-  // }
+
+  /**
+   * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
+   * Space Complexity: O(n) - Additional space is required for the sorted array.
+   */
+
+  /**
+   * Time Complexity: O(log n) - Average case for a balanced tree.
+   * Space Complexity: O(1) - Constant space is used.
+   *
+   * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
+   * leftmost node if the comparison result is greater than.
+   * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
+   * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
+   * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
+   * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+   * be performed. It can have one of the following values:
+   * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
+   * the key of the leftmost node if the comparison result is greater than, and the key of the
+   * rightmost node otherwise. If no node is found, it returns 0.
+   */
+  lastKey(beginRoot: BSTNodeKeyOrNode<K, N> = this.root): K | undefined {
+    let current = this.ensureNode(beginRoot);
+    if (!current) return undefined;
+
+    if (this._variant === BSTVariant.MIN) {
+      // For BSTVariant.MIN, find the rightmost node
+      while (current.right !== undefined) {
+        current = current.right;
+      }
+    } else {
+      // For BSTVariant.MAX, find the leftmost node
+      while (current.left !== undefined) {
+        current = current.left;
+      }
+    }
+    return current.key;
+  }
+
 
   /**
    * Time Complexity: O(log n) - Average case for a balanced tree.
@@ -621,7 +649,6 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
           if (l <= r) {
             const m = l + Math.floor((r - l) / 2);
             const midNode = sorted[m];
-            debugger;
             this.add([midNode.key, midNode.value]);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);

package/src/data-structures/binary-tree/rb-tree.ts

@@ -153,7 +153,7 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
   /**
    * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
    * Space Complexity: O(1)
-   * 
+   *
    * The `add` function adds a new node to a binary search tree and performs necessary rotations and
    * color changes to maintain the red-black tree properties.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an

package/src/data-structures/binary-tree/tree-multimap.ts

@@ -126,7 +126,7 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
   /**
    * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
    * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
-   * 
+   *
    * The function overrides the add method of a binary tree node and adds a new node to the tree.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
    * entry. It represents the key, node, or entry that you want to add to the binary tree.

package/src/data-structures/hash/hash-map.ts

@@ -625,7 +625,7 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   protected* _getIterator() {
     let node = this._head;
     while (node !== this._sentinel) {
-      yield <[K, V]>[node.key, node.value];
+      yield [node.key, node.value] as [K, V];
       node = node.next;
     }
   }

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -162,11 +162,11 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The `popLast()` function removes and returns the value of the last node in a doubly linked list.
+   * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
    * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
    * list is empty, it returns undefined.
    */
-  popLast(): E | undefined {
+  pollLast(): E | undefined {
     return this.pop();
   }
 
@@ -206,11 +206,11 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The `popFirst()` function removes and returns the value of the first node in a doubly linked list.
+   * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
    * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
    * list.
    */
-  popFirst(): E | undefined {
+  pollFirst(): E | undefined {
     return this.shift();
   }
 

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -164,12 +164,12 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
    * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
    * Space Complexity: O(1) - Constant space.
    *
-   * The `popLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
+   * The `pollLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
    * pointers accordingly.
    * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
    * the linked list is empty, it returns `undefined`.
    */
-  popLast(): E | undefined {
+  pollLast(): E | undefined {
     return this.pop();
   }
 
@@ -202,10 +202,10 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
    * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
    * Space Complexity: O(1) - Constant space.
    *
-   * The `popFirst()` function removes and returns the value of the first node in a linked list.
+   * The `pollFirst()` function removes and returns the value of the first node in a linked list.
    * @returns The value of the node that is being removed from the beginning of the linked list.
    */
-  popFirst(): E | undefined {
+  pollFirst(): E | undefined {
     return this.shift();
   }
 

package/src/data-structures/queue/deque.ts

@@ -120,10 +120,10 @@ export class Deque<E> extends IterableElementBase<E> {
    * Time Complexity: O(1) - Removes the last element.
    * Space Complexity: O(1) - Operates in-place.
    *
-   * The function "popLast" removes and returns the last element of an array.
+   * The function "pollLast" removes and returns the last element of an array.
    * @returns The last element of the array is being returned.
    */
-  popLast(): E | undefined {
+  pollLast(): E | undefined {
     return this.pop();
   }
 
@@ -143,11 +143,11 @@ export class Deque<E> extends IterableElementBase<E> {
    * Time Complexity: O(1) - Removes the first element.
    * Space Complexity: O(1) - In-place operation.
    *
-   * The function "popFirst" removes and returns the first element of an array.
-   * @returns The method `popFirst()` is returning the first element of the array after removing it
+   * The function "pollFirst" removes and returns the first element of an array.
+   * @returns The method `pollFirst()` is returning the first element of the array after removing it
    * from the beginning. If the array is empty, it will return `undefined`.
    */
-  popFirst(): E | undefined {
+  pollFirst(): E | undefined {
     return this.shift();
   }
 
@@ -947,10 +947,10 @@ export class ObjectDeque<E = number> {
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The function `popFirst()` removes and returns the first element in a data structure.
+   * The function `pollFirst()` removes and returns the first element in a data structure.
    * @returns The element of the first element in the data structure.
    */
-  popFirst() {
+  pollFirst() {
     if (!this.size) return;
     const element = this.getFirst();
     delete this.nodes[this.first];
@@ -984,10 +984,10 @@ export class ObjectDeque<E = number> {
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The `popLast()` function removes and returns the last element in a data structure.
+   * The `pollLast()` function removes and returns the last element in a data structure.
    * @returns The element that was removed from the data structure.
    */
-  popLast() {
+  pollLast() {
     if (!this.size) return;
     const element = this.getLast();
     delete this.nodes[this.last];
@@ -1039,4 +1039,4 @@ export class ObjectDeque<E = number> {
   isEmpty() {
     return this.size <= 0;
   }
-}
+}

package/src/data-structures/queue/queue.ts

@@ -378,4 +378,4 @@ export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
   peek(): E | undefined {
     return this.getFirst();
   }
-}
+}

package/src/interfaces/binary-tree.ts

@@ -15,7 +15,7 @@ export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V,
 
   add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V, count?: number): N | null | undefined;
 
-  addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>): (N | null | undefined)[];
+  addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[];
 
   delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BiTreeDeleteResult<N>[];
 }

package/src/types/data-structures/binary-tree/rb-tree.ts

@@ -7,4 +7,4 @@ export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNo
 
 export type RedBlackTreeNested<K, V, N extends RedBlackTreeNode<K, V, N>> = RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type RBTreeOptions<K> = BSTOptions<K> & {};
+export type RBTreeOptions<K> = BSTOptions<K> & {};

package/src/types/data-structures/heap/heap.ts

@@ -1,3 +1,3 @@
 import { Comparator } from "../../common";
 
-export type HeapOptions<T> = { comparator: Comparator<T> }
+export type HeapOptions<T> = { comparator: Comparator<T> }

package/src/types/data-structures/priority-queue/priority-queue.ts

@@ -1,3 +1,3 @@
 import { HeapOptions } from "../heap";
 
-export type PriorityQueueOptions<T> = HeapOptions<T> & {}
+export type PriorityQueueOptions<T> = HeapOptions<T> & {}

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

@@ -18,7 +18,7 @@ suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
 });
 
 if (isCompetitor) {
-  suite.add(`${HUNDRED_THOUSAND.toLocaleString()} CPT add`, () => {
+  suite.add(`CPT ${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
     for (let i = 0; i < arr.length; i++) {
       cOrderedMap.setElement(arr[i], arr[i]);
     }

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

@@ -16,7 +16,7 @@ suite.add(`${MILLION.toLocaleString()} set`, () => {
 });
 
 if (isCompetitor) {
-  suite.add(`${MILLION.toLocaleString()} CPT set`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} set`, () => {
     const hm = new CHashMap<number, number>();
 
     for (let i = 0; i < MILLION; i++) {
@@ -25,13 +25,13 @@ if (isCompetitor) {
   });
 }
 
-suite.add(`${MILLION.toLocaleString()} Map set`, () => {
+suite.add(`Native Map ${MILLION.toLocaleString()} set`, () => {
   const hm = new Map<number, number>();
 
   for (let i = 0; i < MILLION; i++) hm.set(i, i);
 });
 
-suite.add(`${MILLION.toLocaleString()} Set add`, () => {
+suite.add(`Native Set ${MILLION.toLocaleString()} add`, () => {
   const hs = new Set<number>();
 
   for (let i = 0; i < MILLION; i++) hs.add(i);
@@ -49,7 +49,7 @@ suite.add(`${MILLION.toLocaleString()} set & get`, () => {
 });
 
 if (isCompetitor) {
-  suite.add(`${MILLION.toLocaleString()} CPT set & get`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} set & get`, () => {
     const hm = new CHashMap<number, number>();
 
     for (let i = 0; i < MILLION; i++) {
@@ -61,7 +61,7 @@ if (isCompetitor) {
   });
 }
 
-suite.add(`${MILLION.toLocaleString()} Map set & get`, () => {
+suite.add(`Native Map ${MILLION.toLocaleString()} set & get`, () => {
   const hm = new Map<number, number>();
 
   for (let i = 0; i < MILLION; i++) {
@@ -72,7 +72,7 @@ suite.add(`${MILLION.toLocaleString()} Map set & get`, () => {
   }
 });
 
-suite.add(`${MILLION.toLocaleString()} Set add & has`, () => {
+suite.add(`Native Set ${MILLION.toLocaleString()} add & has`, () => {
   const hs = new Set<number>();
 
   for (let i = 0; i < MILLION; i++) hs.add(i);
@@ -94,7 +94,7 @@ suite.add(`${MILLION.toLocaleString()} ObjKey set & get`, () => {
   }
 });
 
-suite.add(`${MILLION.toLocaleString()} Map ObjKey set & get`, () => {
+suite.add(`Native Map ${MILLION.toLocaleString()} ObjKey set & get`, () => {
   const hm = new Map<[number, number], number>();
   const objs: [number, number][] = [];
   for (let i = 0; i < MILLION; i++) {
@@ -107,7 +107,7 @@ suite.add(`${MILLION.toLocaleString()} Map ObjKey set & get`, () => {
   }
 });
 
-suite.add(`${MILLION.toLocaleString()} Set ObjKey add & has`, () => {
+suite.add(`Native Set ${MILLION.toLocaleString()} ObjKey add & has`, () => {
   const hs = new Set<[number, number]>();
   const objs: [number, number][] = [];
   for (let i = 0; i < MILLION; i++) {

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

@@ -17,7 +17,7 @@ suite.add(`${LINEAR.toLocaleString()} push`, () => {
 
 
 if (isCompetitor) {
-  suite.add(`${LINEAR.toLocaleString()} CPT push`, () => {
+  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
     const list = new CLinkedList<number>();
 
     for (let i = 0; i < LINEAR; i++) {
@@ -35,7 +35,7 @@ suite.add(`${LINEAR.toLocaleString()} unshift`, () => {
 });
 
 if (isCompetitor) {
-  suite.add(`${LINEAR.toLocaleString()} CPT unshift`, () => {
+  suite.add(`CPT ${LINEAR.toLocaleString()} unshift`, () => {
     const list = new CLinkedList<number>();
 
     for (let i = 0; i < LINEAR; i++) {

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

@@ -3,9 +3,20 @@ import * as Benchmark from 'benchmark';
 import { magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const { TEN_THOUSAND } = magnitude;
+const { MILLION, TEN_THOUSAND } = magnitude;
 
 suite
+  .add(`${MILLION.toLocaleString()} push & shift`, () => {
+    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>();
 

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

@@ -19,7 +19,7 @@ suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
   }
 });
 if (isCompetitor) {
-  suite.add(`${HUNDRED_THOUSAND.toLocaleString()} CPT add & pop`, () => {
+  suite.add(`CPT ${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
     const pq = new CPriorityQueue<number>();
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) {