data-structure-typed 1.49.3 → 1.49.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.49.3",
+  "version": "1.49.4",
   "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",

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

@@ -1957,7 +1957,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     }
   }
 
-  protected _defaultOneParamCallback = (node: N) => node.key;
+  protected _defaultOneParamCallback = (node: N | null | undefined) => node ? node.key : undefined;
 
   /**
    * Swap the data of two nodes in the binary tree.

package/src/data-structures/graph/abstract-graph.ts

@@ -173,19 +173,7 @@ export abstract class AbstractGraph<
    * Space Complexity: O(1) - Constant space, as it creates only a few variables.
    */
 
-  /**
-   * Time Complexity: O(1) - Constant time for Map operations.
-   * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-   *
-   * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
-   * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
-   * (`VertexKey`).
-   * @returns The method is returning a boolean value.
-   */
-  deleteVertex(vertexOrKey: VO | VertexKey): boolean {
-    const vertexKey = this._getVertexKey(vertexOrKey);
-    return this._vertexMap.delete(vertexKey);
-  }
+  abstract deleteVertex(vertexOrKey: VO | VertexKey): boolean;
 
   /**
    * Time Complexity: O(K), where K is the number of vertexMap to be removed.

package/src/data-structures/graph/directed-graph.ts

@@ -240,7 +240,7 @@ export class DirectedGraph<
    * (`VertexKey`).
    * @returns The method is returning a boolean value.
    */
-  override deleteVertex(vertexOrKey: VO | VertexKey): boolean {
+  deleteVertex(vertexOrKey: VO | VertexKey): boolean {
     let vertexKey: VertexKey;
     let vertex: VO | undefined;
     if (this.isVertexKey(vertexOrKey)) {
@@ -252,8 +252,12 @@ export class DirectedGraph<
     }
 
     if (vertex) {
-      this._outEdgeMap.delete(vertex)
-      this._inEdgeMap.delete(vertex)
+      const neighbors = this.getNeighbors(vertex);
+      for (const neighbor of neighbors) {
+        this._inEdgeMap.delete(neighbor);
+      }
+      this._outEdgeMap.delete(vertex);
+      this._inEdgeMap.delete(vertex);
     }
 
     return this._vertexMap.delete(vertexKey);

package/src/data-structures/graph/undirected-graph.ts

@@ -212,7 +212,7 @@ export class UndirectedGraph<
    * (`VertexKey`).
    * @returns The method is returning a boolean value.
    */
-  override deleteVertex(vertexOrKey: VO | VertexKey): boolean {
+  deleteVertex(vertexOrKey: VO | VertexKey): boolean {
     let vertexKey: VertexKey;
     let vertex: VO | undefined;
     if (this.isVertexKey(vertexOrKey)) {

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

@@ -33,8 +33,7 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
     this._tail = undefined;
     this._size = 0;
     if (elements) {
-      for (const el of elements)
-        this.push(el);
+      for (const el of elements) this.push(el);
     }
   }
 

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

@@ -16,7 +16,7 @@ import { getRandomIntArray, magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { TEN_THOUSAND, HUNDRED_THOUSAND, LINEAR } = magnitude;
+const { TEN_THOUSAND, HUNDRED_THOUSAND, MILLION } = magnitude;
 const cOrderedMap = new OrderedMap<number, number>();
 const arrHundredThousand = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND, true);
 
@@ -96,10 +96,10 @@ if (isCompetitor) {
         hm.getElementByKey(i);
       }
     })
-    .add(`CPT LL ${LINEAR.toLocaleString()} unshift`, () => {
+    .add(`CPT LL ${MILLION.toLocaleString()} unshift`, () => {
       const list = new CLinkedList<number>();
 
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         list.pushFront(i);
       }
     })
@@ -114,33 +114,33 @@ if (isCompetitor) {
         pq.pop();
       }
     })
-    .add(`CPT DQ ${LINEAR.toLocaleString()} push`, () => {
+    .add(`CPT DQ ${MILLION.toLocaleString()} push`, () => {
       const deque = new CDeque<number>();
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         deque.pushBack(i);
       }
     })
-    .add(`CPT Q ${LINEAR.toLocaleString()} push`, () => {
+    .add(`CPT Q ${MILLION.toLocaleString()} push`, () => {
       const queue = new CQueue<number>();
 
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         queue.push(i);
       }
     })
-    .add(`CPT ST ${LINEAR.toLocaleString()} push`, () => {
+    .add(`CPT ST ${MILLION.toLocaleString()} push`, () => {
       const queue = new CStack<number>();
 
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         queue.push(i);
       }
     })
-    .add(`CPT ST ${LINEAR.toLocaleString()} push & pop`, () => {
+    .add(`CPT ST ${MILLION.toLocaleString()} push & pop`, () => {
       const queue = new CStack<number>();
 
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         queue.push(i);
       }
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         queue.pop();
       }
     });

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

@@ -5,61 +5,50 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { LINEAR } = magnitude;
+const { MILLION } = magnitude;
 
-suite.add(`${LINEAR.toLocaleString()} push`, () => {
+suite.add(`${MILLION.toLocaleString()} push`, () => {
   const list = new DoublyLinkedList<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
-    list.push(i);
-  }
+  for (let i = 0; i < MILLION; i++) list.push(i);
 });
 
 
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const list = new CLinkedList<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
-      list.pushBack(i);
-    }
+    for (let i = 0; i < MILLION; i++) list.pushBack(i);
   });
 }
 
-suite.add(`${LINEAR.toLocaleString()} unshift`, () => {
+suite.add(`${MILLION.toLocaleString()} unshift`, () => {
   const list = new DoublyLinkedList<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
-    list.unshift(i);
-  }
+  for (let i = 0; i < MILLION; i++) list.unshift(i);
 });
 
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} unshift`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} unshift`, () => {
     const list = new CLinkedList<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
-      list.pushFront(i);
-    }
+    for (let i = 0; i < MILLION; i++) list.pushFront(i);
   });
 }
 
 suite
-  .add(`${LINEAR.toLocaleString()} unshift & shift`, () => {
+  .add(`${MILLION.toLocaleString()} unshift & shift`, () => {
     const list = new DoublyLinkedList<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
-      list.unshift(i);
-    }
-    for (let i = 0; i < LINEAR; i++) {
-      list.shift();
-    }
+    for (let i = 0; i < MILLION; i++) list.unshift(i);
+
+    for (let i = 0; i < MILLION; i++) list.shift();
   })
-  .add(`${LINEAR.toLocaleString()} addBefore`, () => {
+  .add(`${MILLION.toLocaleString()} addBefore`, () => {
     const doublyList = new DoublyLinkedList<number>();
     let midNode: DoublyLinkedListNode | undefined;
-    const midIndex = Math.floor(LINEAR / 2);
-    for (let i = 0; i < LINEAR; i++) {
+    const midIndex = Math.floor(MILLION / 2);
+    for (let i = 0; i < MILLION; i++) {
       doublyList.push(i);
       if (i === midIndex) {
         midNode = doublyList.getNode(i);

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

@@ -9,24 +9,16 @@ 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.push(i);
 
-    for (let i = 0; i < MILLION; i++) {
-      list.shift();
-    }
+    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.push(i);
 
-    for (let i = 0; i < TEN_THOUSAND; i++) {
-      list.pop();
-    }
+    for (let i = 0; i < TEN_THOUSAND; i++) list.pop();
   })
   .add(`${TEN_THOUSAND.toLocaleString()} addBefore`, () => {
     const singlyList = new SinglyLinkedList<number>();

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

@@ -5,26 +5,26 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 export const suite = new Benchmark.Suite();
-const { LINEAR, HUNDRED_THOUSAND } = magnitude;
+const { MILLION, HUNDRED_THOUSAND } = magnitude;
 
-suite.add(`${LINEAR.toLocaleString()} push`, () => {
+suite.add(`${MILLION.toLocaleString()} push`, () => {
   const deque = new Deque<number>();
-  for (let i = 0; i < LINEAR; i++) deque.push(i);
+  for (let i = 0; i < MILLION; i++) deque.push(i);
 });
 
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const _deque = new CDeque<number>();
-    for (let i = 0; i < LINEAR; i++) _deque.pushBack(i);
+    for (let i = 0; i < MILLION; i++) _deque.pushBack(i);
   });
 }
 
 
-suite.add(`${LINEAR.toLocaleString()} push & pop`, () => {
+suite.add(`${MILLION.toLocaleString()} push & pop`, () => {
   const _deque = new Deque<number>();
 
-  for (let i = 0; i < LINEAR; i++) _deque.push(i);
-  for (let i = 0; i < LINEAR; i++) _deque.pop();
+  for (let i = 0; i < MILLION; i++) _deque.push(i);
+  for (let i = 0; i < MILLION; i++) _deque.pop();
 
 })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {

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

@@ -5,20 +5,20 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { LINEAR, HUNDRED_THOUSAND } = magnitude;
+const { MILLION, HUNDRED_THOUSAND } = magnitude;
 
-suite.add(`${LINEAR.toLocaleString()} push`, () => {
+suite.add(`${MILLION.toLocaleString()} push`, () => {
   const queue = new Queue<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
+  for (let i = 0; i < MILLION; i++) {
     queue.push(i);
   }
 });
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const queue = new CQueue<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
+    for (let i = 0; i < MILLION; i++) {
       queue.push(i);
     }
   });

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

@@ -5,42 +5,42 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { LINEAR } = magnitude;
+const { MILLION } = magnitude;
 
-suite.add(`${LINEAR.toLocaleString()} push`, () => {
+suite.add(`${MILLION.toLocaleString()} push`, () => {
   const stack = new Stack<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
+  for (let i = 0; i < MILLION; i++) {
     stack.push(i);
   }
 });
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const queue = new CStack<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
+    for (let i = 0; i < MILLION; i++) {
       queue.push(i);
     }
   });
 }
-suite.add(`${LINEAR.toLocaleString()} push & pop`, () => {
+suite.add(`${MILLION.toLocaleString()} push & pop`, () => {
   const queue = new Stack<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
+  for (let i = 0; i < MILLION; i++) {
     queue.push(i);
   }
-  for (let i = 0; i < LINEAR; i++) {
+  for (let i = 0; i < MILLION; i++) {
     queue.pop();
   }
 });
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} push & pop`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} push & pop`, () => {
     const queue = new CStack<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
+    for (let i = 0; i < MILLION; i++) {
       queue.push(i);
     }
-    for (let i = 0; i < LINEAR; i++) {
+    for (let i = 0; i < MILLION; i++) {
       queue.pop();
     }
   });

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

@@ -639,4 +639,19 @@ describe('BinaryTree iterative methods test', () => {
     const values = binaryTree.values();
     expect([...values]).toEqual(['b', 'a', 'c']);
   });
+
+  test('should iterative method return undefined when the node is null', () => {
+    const tree = new BinaryTree()
+    tree.addMany([-10, -10, -10, 9, 9, 20, null, null, 15, 7, 8, null, 2, null, 6, null, null, 8, 8, 8]);
+    const bfsResult = tree.bfs(undefined, undefined, undefined, true);
+    expect(bfsResult).toEqual([
+      -10, 9,
+      20, undefined,
+      undefined, 15,
+      7, 8,
+      undefined, 2,
+      undefined, 6,
+      undefined, undefined
+    ]);
+  })
 });

package/test/unit/data-structures/graph/abstract-graph.test.ts

@@ -66,6 +66,17 @@ class MyGraph<
     return edge ? undefined : undefined;
   }
 
+  deleteVertex(vertexOrKey: VertexKey | VO): boolean {
+    let vertexKey: VertexKey;
+    if (this.isVertexKey(vertexOrKey)) {
+      vertexKey = vertexOrKey;
+    } else {
+      vertexKey = vertexOrKey.key;
+    }
+    this._vertexMap.delete(vertexKey);
+    return true;
+  }
+
   protected _addEdge(edge: EO): boolean {
     return edge ? true : true;
   }

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

@@ -635,7 +635,7 @@ describe('DirectedGraph iterative Methods', () => {
     expect(concatenated).toBe(vertexMap.join(''));
   });
 
-  test('Removing an edge of a DirectedGraph should not delete additional edges', () => {
+  test('Removing an edge of a DirectedGraph should delete additional edges', () => {
     const dg = new DirectedGraph();
     dg.addVertex('hello')
     dg.addVertex('hi')
@@ -649,9 +649,22 @@ describe('DirectedGraph iterative Methods', () => {
     dg.deleteEdge('hello', 'hi')
     expect(dg.getEdge('hello', 'hi')).toBe(undefined)
     expect(dg.getEdge('hello', 'hey')).toBeInstanceOf(DirectedEdge)
+    expect(dg.incomingEdgesOf("Hi")).toEqual([])
   });
 
-  test('Removing a vertex from a UndirectedGraph should remove its edges', () => {
+  test('Removing a vertex of a DirectedGraph should delete additional edges', () => {
+    const graph = new DirectedGraph();
+
+    graph.addVertex("Hello");
+    graph.addVertex("Hi");
+
+    graph.addEdge("Hello", "Hi");
+    graph.deleteVertex("Hello");
+
+    expect(graph.incomingEdgesOf("Hi")).toEqual([]);
+  })
+
+  test('Removing a vertex from a DirectedGraph should remove its edges', () => {
     const dg = new DirectedGraph();
     dg.addVertex('hello')
     dg.addVertex('world')

package/test/unit/data-structures/graph/undirected-graph.test.ts

@@ -190,6 +190,19 @@ describe('UndirectedGraph', () => {
     expect(dg.getEdge('hello', 'hey')).toBeInstanceOf(UndirectedEdge)
   });
 
+
+  test('Removing a vertex of a DirectedGraph should delete additional edges', () => {
+    const graph = new UndirectedGraph();
+
+    graph.addVertex("Hello");
+    graph.addVertex("Hi");
+
+    graph.addEdge("Hello", "Hi");
+    graph.deleteVertex("Hello");
+
+    expect(graph.edgesOf("Hi")).toEqual([]);
+  })
+
   test('Removing a vertex from a UndirectedGraph should remove its edges', () => {
     const dg = new UndirectedGraph();
     dg.addVertex('hello')

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

@@ -554,4 +554,25 @@ describe('LinkedHashMap setMany, keys, values', () => {
   test('values', () => {
     expect([...hm.values()]).toEqual([2, 3, 4, 5, 6])
   });
+
+  test('entries', () => {
+    expect([...hm.entries()]).toEqual([[2, 2], [3, 3], [4, 4], [5, 5], [6, 6]])
+  });
+
+  test('every', () => {
+    expect(hm.every(value => value > 4)).toBe(false)
+  });
+
+  test('some', () => {
+    expect(hm.some(value => value > 6)).toBe(false)
+  });
+
+  test('hasValue', () => {
+    expect(hm.hasValue(3)).toBe(true)
+    expect(hm.hasValue(7)).toBe(false)
+  });
+
+  test('print', () => {
+    hm.print();
+  });
 });

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

@@ -424,4 +424,31 @@ describe('iterable methods', () => {
     expect([...dl.map(element => element * 2)]).toEqual([2, 4, 6]);
     expect(dl.reduce((accumulator, element) => accumulator + element, 0)).toEqual(6);
   });
+
+  test('values', () => {
+    const dl = new DoublyLinkedList<number>()
+    dl.push(1);
+    dl.push(2);
+    dl.push(3);
+    dl.delete(2);
+    dl.unshift(0);
+    dl.shift();
+    dl.pop();
+    dl.unshift(3);
+    expect([...dl.values()]).toEqual([3, 1])
+  })
+
+  test('some', () => {
+    const dl = new DoublyLinkedList<number>()
+    dl.push(1);
+    dl.push(2);
+    dl.push(3);
+    dl.delete(2);
+    dl.unshift(0);
+    dl.shift();
+    dl.pop();
+    dl.unshift(3);
+    expect(dl.some(value => value > 1)).toBe(true)
+    expect(dl.some(value => value > 100)).toBe(false)
+  })
 });

package/test/utils/big-o.ts

@@ -2,16 +2,16 @@ import { AnyFunction } from '../types';
 import { isDebugTest } from '../config';
 
 const isDebug = isDebugTest;
-const orderReducedBy = 1; // reduction of bigO's order compared to the baseline bigO
+// const orderReducedBy = 1; // reduction of bigO's order compared to the baseline bigO
 
 export const magnitude = {
-  CONSTANT: Math.pow(10, 9),
-  LOG_N: Math.pow(10, 8 - orderReducedBy),
-  LINEAR: Math.pow(10, 7 - orderReducedBy),
-  N_LOG_N: Math.pow(10, 4 - orderReducedBy),
-  SQUARED: Math.pow(10, 3 - orderReducedBy),
-  CUBED: Math.pow(10, 2 - orderReducedBy),
-  FACTORIAL: 20 - orderReducedBy,
+  // CONSTANT: Math.pow(10, 9),
+  // LOG_N: Math.pow(10, 8 - orderReducedBy),
+  // LINEAR: Math.pow(10, 7 - orderReducedBy),
+  // N_LOG_N: Math.pow(10, 4 - orderReducedBy),
+  // SQUARED: Math.pow(10, 3 - orderReducedBy),
+  // CUBED: Math.pow(10, 2 - orderReducedBy),
+  // FACTORIAL: 20 - orderReducedBy,
   THOUSAND: 1000,
   TEN_THOUSAND: 10000,
   HUNDRED_THOUSAND: 100000,
@@ -21,12 +21,12 @@ export const magnitude = {
 };
 
 export const bigO = {
-  CONSTANT: magnitude.CONSTANT / 100000,
-  LOG_N: Math.log2(magnitude.LOG_N) / 1000,
-  LINEAR: magnitude.LINEAR / 1000,
-  N_LOG_N: (magnitude.N_LOG_N * Math.log2(magnitude.LOG_N)) / 1000,
-  SQUARED: Math.pow(magnitude.SQUARED, 2) / 1000,
-  CUBED: Math.pow(magnitude.SQUARED, 3) / 1000,
+  // CONSTANT: magnitude.CONSTANT / 100000,
+  // LOG_N: Math.log2(magnitude.LOG_N) / 1000,
+  // LINEAR: magnitude.LINEAR / 1000,
+  // N_LOG_N: (magnitude.N_LOG_N * Math.log2(magnitude.LOG_N)) / 1000,
+  // SQUARED: Math.pow(magnitude.SQUARED, 2) / 1000,
+  // CUBED: Math.pow(magnitude.SQUARED, 3) / 1000,
   FACTORIAL: 10000
 };