data-structure-typed 1.38.8 → 1.39.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.38.8",
+  "version": "1.39.0",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
@@ -61,17 +61,17 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.38.7",
+    "avl-tree-typed": "^1.38.9",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.38.7",
-    "bst-typed": "^1.38.7",
+    "binary-tree-typed": "^1.38.9",
+    "bst-typed": "^1.38.9",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-import-resolver-alias": "^1.1.2",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
-    "heap-typed": "^1.38.7",
+    "heap-typed": "^1.38.9",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",

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

@@ -143,6 +143,26 @@ export class BinaryIndexedTree {
     return this._binarySearch(sum, (x, y) => x <= y);
   }
 
+  /**
+   * The function calculates the prefix sum of an array using a binary indexed tree.
+   * @param {number} i - The parameter "i" in the function "getPrefixSum" represents the index of the element in the
+   * array for which we want to calculate the prefix sum.
+   * @returns The function `getPrefixSum` returns the prefix sum of the elements in the binary indexed tree up to index
+   * `i`.
+   */
+  getPrefixSum(i: number): number {
+    this._checkIndex(i);
+    i++; // Convert to 1-based index
+
+    let sum = 0;
+    while (i > 0) {
+      sum += this._getFrequency(i);
+      i -= i & -i;
+    }
+
+    return sum;
+  }
+
   /**
    * The function returns the value of a specific index in a freqMap data structure, or a default value if
    * the index is not found.

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

@@ -115,7 +115,8 @@ export class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTree
  * Represents a binary tree data structure.
  * @template N - The type of the binary tree's nodes.
  */
-export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>> implements IBinaryTree<V, N> {
+export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>>
+  implements IBinaryTree<V, N> {
   /**
    * Creates a new instance of BinaryTree.
    * @param {BinaryTreeOptions} [options] - The options for the binary tree.
@@ -974,7 +975,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
           if (current.left) queue.push(current.left);
           if (current.right) queue.push(current.right);
         }
-
       }
     }
     return ans;

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

@@ -24,7 +24,9 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
   }
 }
 
-export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>> extends BinaryTree<V, N> implements IBinaryTree<V, N> {
+export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>>
+  extends BinaryTree<V, N>
+  implements IBinaryTree<V, N> {
   /**
    * The constructor function initializes a binary search tree object with an optional comparator
    * function.

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

@@ -19,7 +19,9 @@ export class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V
   }
 }
 
-export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
+export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>>
+  extends BST<V, N>
+  implements IBinaryTree<V, N> {
   constructor(options?: RBTreeOptions) {
     super(options);
   }

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

@@ -130,7 +130,7 @@ export abstract class AbstractGraph<
    */
   abstract createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): E;
 
-  abstract removeEdge(edge: E): E | null;
+  abstract deleteEdge(edge: E): E | null;
 
   abstract getEdge(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null;
 
@@ -179,12 +179,12 @@ export abstract class AbstractGraph<
   }
 
   /**
-   * The `removeVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+   * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
    * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
    * (`VertexKey`).
    * @returns The method is returning a boolean value.
    */
-  removeVertex(vertexOrKey: V | VertexKey): boolean {
+  deleteVertex(vertexOrKey: V | VertexKey): boolean {
     const vertexKey = this._getVertexKey(vertexOrKey);
     return this._vertices.delete(vertexKey);
   }
@@ -199,7 +199,7 @@ export abstract class AbstractGraph<
   removeAllVertices(vertices: V[] | VertexKey[]): boolean {
     const removed: boolean[] = [];
     for (const v of vertices) {
-      removed.push(this.removeVertex(v));
+      removed.push(this.deleteVertex(v));
     }
     return removed.length > 0;
   }
@@ -622,7 +622,7 @@ export abstract class AbstractGraph<
       if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
     }
 
-    const heap = new PriorityQueue<{ key: number; val: V }>((a, b) => a.key - b.key);
+    const heap = new PriorityQueue<{ key: number; val: V }>({comparator: (a, b) => a.key - b.key});
     heap.add({key: 0, val: srcVertex});
 
     distMap.set(srcVertex, 0);

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

@@ -153,7 +153,7 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
    * @param {V | VertexKey} destOrKey - The `destOrKey` parameter represents the destination vertex or its ID.
    * @returns the removed edge (E) if it exists, or null if either the source or destination vertex does not exist.
    */
-  removeEdgeSrcToDest(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null {
+  deleteEdgeSrcToDest(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null {
     const src: V | null = this._getVertex(srcOrKey);
     const dest: V | null = this._getVertex(destOrKey);
     let removed: E | null = null;
@@ -177,9 +177,9 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
    * The function removes an edge from a graph and returns the removed edge, or null if the edge was not found.
    * @param {E} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
    * and `dest`, which represent the source and destination vertices of the edge, respectively.
-   * @returns The method `removeEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
+   * @returns The method `deleteEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
    */
-  removeEdge(edge: E): E | null {
+  deleteEdge(edge: E): E | null {
     let removed: E | null = null;
     const src = this._getVertex(edge.src);
     const dest = this._getVertex(edge.dest);
@@ -206,12 +206,12 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
    * the second vertex in the edge that needs to be removed.
    * @returns an array of removed edges (E[]).
    */
-  removeEdgesBetween(v1: VertexKey | V, v2: VertexKey | V): E[] {
+  deleteEdgesBetween(v1: VertexKey | V, v2: VertexKey | V): E[] {
     const removed: E[] = [];
 
     if (v1 && v2) {
-      const v1ToV2 = this.removeEdgeSrcToDest(v1, v2);
-      const v2ToV1 = this.removeEdgeSrcToDest(v2, v1);
+      const v1ToV2 = this.deleteEdgeSrcToDest(v1, v2);
+      const v2ToV1 = this.deleteEdgeSrcToDest(v2, v1);
 
       v1ToV2 && removed.push(v1ToV2);
       v2ToV1 && removed.push(v2ToV1);

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

@@ -127,7 +127,7 @@ export class UndirectedGraph<
    * (VertexKey). It represents the second vertex of the edge that needs to be removed.
    * @returns the removed edge (E) if it exists, or null if either of the vertices (V) does not exist.
    */
-  removeEdgeBetween(v1: V | VertexKey, v2: V | VertexKey): E | null {
+  deleteEdgeBetween(v1: V | VertexKey, v2: V | VertexKey): E | null {
     const vertex1: V | null = this._getVertex(v1);
     const vertex2: V | null = this._getVertex(v2);
 
@@ -148,12 +148,12 @@ export class UndirectedGraph<
   }
 
   /**
-   * The removeEdge function removes an edge between two vertices in a graph.
+   * The deleteEdge function removes an edge between two vertices in a graph.
    * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
    * @returns The method is returning either the removed edge (of type E) or null if the edge was not found.
    */
-  removeEdge(edge: E): E | null {
-    return this.removeEdgeBetween(edge.vertices[0], edge.vertices[1]);
+  deleteEdge(edge: E): E | null {
+    return this.deleteEdgeBetween(edge.vertices[0], edge.vertices[1]);
   }
 
   /**

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

@@ -7,12 +7,16 @@
 
 import type {Comparator, DFSOrderPattern} from '../../types';
 
-export class Heap<E> {
+export class Heap<E = any> {
   protected nodes: E[] = [];
   protected readonly comparator: Comparator<E>;
 
-  constructor(comparator: Comparator<E>) {
-    this.comparator = comparator;
+  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
+    this.comparator = options.comparator;
+    if (options.nodes && options.nodes.length > 0) {
+      this.nodes = options.nodes;
+      this.fix();
+    }
   }
 
   /**
@@ -32,15 +36,11 @@ export class Heap<E> {
 
   /**
    * Static method that creates a binary heap from an array of nodes and a comparison function.
-   * @param nodes
-   * @param comparator - Comparison function.
    * @returns A new Heap instance.
+   * @param options
    */
-  static heapify<E>(nodes: E[], comparator: Comparator<E>): Heap<E> {
-    const binaryHeap = new Heap<E>(comparator);
-    binaryHeap.nodes = [...nodes];
-    binaryHeap.fix(); // Fix heap properties
-    return binaryHeap;
+  static heapify<E>(options: { nodes: E[]; comparator: Comparator<E> }): Heap<E> {
+    return new Heap<E>(options);
   }
 
   /**
@@ -180,7 +180,7 @@ export class Heap<E> {
    * @returns A new Heap instance containing the same elements.
    */
   clone(): Heap<E> {
-    const clonedHeap = new Heap<E>(this.comparator);
+    const clonedHeap = new Heap<E>({comparator: this.comparator});
     clonedHeap.nodes = [...this.nodes];
     return clonedHeap;
   }
@@ -269,7 +269,7 @@ export class FibonacciHeapNode<E> {
 
 export class FibonacciHeap<E> {
   root?: FibonacciHeapNode<E>;
-  size: number = 0;
+  size = 0;
   protected min?: FibonacciHeapNode<E>;
   protected readonly comparator: Comparator<E>;
 

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

@@ -11,14 +11,16 @@ import type {Comparator} from '../../types';
 
 export class MaxHeap<E = any> extends Heap<E> {
   constructor(
-    comparator: Comparator<E> = (a: E, b: E) => {
-      if (!(typeof a === 'number' && typeof b === 'number')) {
-        throw new Error('The a, b params of compare function must be number');
-      } else {
-        return b - a;
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
+      comparator: (a: E, b: E) => {
+        if (!(typeof a === 'number' && typeof b === 'number')) {
+          throw new Error('The a, b params of compare function must be number');
+        } else {
+          return b - a;
+        }
       }
     }
   ) {
-    super(comparator);
+    super(options);
   }
 }

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

@@ -11,14 +11,16 @@ import type {Comparator} from '../../types';
 
 export class MinHeap<E = any> extends Heap<E> {
   constructor(
-    comparator: Comparator<E> = (a: E, b: E) => {
-      if (!(typeof a === 'number' && typeof b === 'number')) {
-        throw new Error('The a, b params of compare function must be number');
-      } else {
-        return a - b;
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
+      comparator: (a: E, b: E) => {
+        if (!(typeof a === 'number' && typeof b === 'number')) {
+          throw new Error('The a, b params of compare function must be number');
+        } else {
+          return a - b;
+        }
       }
     }
   ) {
-    super(comparator);
+    super(options);
   }
 }

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

@@ -10,14 +10,16 @@ import type {Comparator} from '../../types';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    compare: Comparator<E> = (a: E, b: E) => {
-      if (!(typeof a === 'number' && typeof b === 'number')) {
-        throw new Error('The a, b params of compare function must be number');
-      } else {
-        return b - a;
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
+      comparator: (a: E, b: E) => {
+        if (!(typeof a === 'number' && typeof b === 'number')) {
+          throw new Error('The a, b params of compare function must be number');
+        } else {
+          return b - a;
+        }
       }
     }
   ) {
-    super(compare);
+    super(options);
   }
 }

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

@@ -10,14 +10,16 @@ import type {Comparator} from '../../types';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    compare: Comparator<E> = (a: E, b: E) => {
-      if (!(typeof a === 'number' && typeof b === 'number')) {
-        throw new Error('The a, b params of compare function must be number');
-      } else {
-        return a - b;
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
+      comparator: (a: E, b: E) => {
+        if (!(typeof a === 'number' && typeof b === 'number')) {
+          throw new Error('The a, b params of compare function must be number');
+        } else {
+          return a - b;
+        }
       }
     }
   ) {
-    super(compare);
+    super(options);
   }
 }

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

@@ -9,8 +9,8 @@
 import {Heap} from '../heap';
 import {Comparator} from '../../types';
 
-export class PriorityQueue<E> extends Heap<E> {
-  constructor(comparator: Comparator<E>) {
-    super(comparator);
+export class PriorityQueue<E = any> extends Heap<E> {
+  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
+    super(options);
   }
 }

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

@@ -241,9 +241,10 @@ export class Trie {
    * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
    * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
    * @param {number} max - The max count of words will be found
+   * @param isAllWhenEmptyPrefix - If true, when the prefix provided as '', returns all the words in the trie.
    * @returns {string[]} an array of strings.
    */
-  getWords(prefix = '', max = Number.MAX_SAFE_INTEGER): string[] {
+  getWords(prefix = '', max = Number.MAX_SAFE_INTEGER, isAllWhenEmptyPrefix = false): string[] {
     prefix = this._caseProcess(prefix);
     const words: string[] = [];
     let found = 0;
@@ -270,7 +271,8 @@ export class Trie {
         if (nodeC) startNode = nodeC;
       }
     }
-    if (startNode !== this.root) dfs(startNode, prefix);
+
+    if (isAllWhenEmptyPrefix || startNode !== this.root) dfs(startNode, prefix);
 
     return words;
   }

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

@@ -283,3 +283,38 @@ function loopLowerBoundTests(bit: BinaryIndexedTree, values: number[]) {
     }
   }
 }
+
+describe('', () => {
+  class NumArrayDC {
+    private _tree: BinaryIndexedTree;
+    private readonly _nums: number[];
+
+    constructor(nums: number[]) {
+      this._nums = nums;
+      this._tree = new BinaryIndexedTree({max: nums.length + 1});
+      for (let i = 0; i < nums.length; i++) {
+        this._tree.update(i + 1, nums[i]);
+      }
+    }
+
+    update(index: number, val: number): void {
+      this._tree.update(index + 1, val - this._nums[index]);
+      this._nums[index] = val;
+    }
+
+    sumRange(left: number, right: number): number {
+      return this._tree.getPrefixSum(right + 1) - this._tree.getPrefixSum(left);
+    }
+  }
+
+  it('', () => {
+    const numArray = new NumArrayDC([1, 3, 5, 8, 2, 9, 4, 5, 8, 1, 3, 2]);
+    expect(numArray.sumRange(0, 8)).toBe(45);
+    expect(numArray.sumRange(0, 2)).toBe(9);
+    numArray.update(1, 2);
+    expect(numArray.sumRange(0, 2)).toBe(8);
+    expect(numArray.sumRange(3, 4)).toBe(10);
+    numArray.update(3, 2);
+    expect(numArray.sumRange(3, 4)).toBe(4);
+  });
+});

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

@@ -1,5 +1,5 @@
 import {AVLTree, AVLTreeNode, BinaryTree, BinaryTreeNode, IterationType} from '../../../../src';
-import {isDebugTest} from "../../../config";
+import {isDebugTest} from '../../../config';
 
 const isDebug = isDebugTest;
 // const isDebug = true;
@@ -226,11 +226,14 @@ describe('BinaryTree traversals', () => {
   expect(tree.dfs(node => node.key, 'pre')).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
   expect(tree.dfs(node => node.key, 'in')).toEqual([15, 16, 20, 28, 29, 30, 35, 40, 45, 50, 55]);
   expect(tree.dfs(node => node.key, 'post')).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
-  expect(tree.bfs(node => node.key, tree.root, IterationType.RECURSIVE)).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
-  expect(tree.bfs(node => node.key, tree.root, IterationType.ITERATIVE)).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
+  expect(tree.bfs(node => node.key, tree.root, IterationType.RECURSIVE)).toEqual([
+    35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
+  ]);
+  expect(tree.bfs(node => node.key, tree.root, IterationType.ITERATIVE)).toEqual([
+    35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
+  ]);
 
   const levels = tree.listLevels(node => node.key);
   expect(levels).toEqual([[35], [20, 40], [15, 29, 50], [16, 28, 30, 45, 55]]);
   isDebug && console.log(levels);
-
-})
+});

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

@@ -435,7 +435,7 @@ describe('BST Performance test', function () {
     bst.addMany(nodes);
     isDebug && console.log('---add', performance.now() - start);
     const startL = performance.now();
-    const arr: number[][] = bst.listLevels((node) => node.key);
+    const arr: number[][] = bst.listLevels(node => node.key);
     isDebug && console.log('---listLevels', arr);
     isDebug && console.log('---listLevels', performance.now() - startL);
   });

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

@@ -6,27 +6,27 @@ describe('Overall BinaryTree Test', () => {
     bst.add(11);
     bst.add(3);
     bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], undefined, false);
-    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
+    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?.key === 1;                            // true
+    leftMost?.key === 1; // true
     expect(leftMost?.key).toBe(1);
     bst.delete(6);
-    bst.get(6);                                     // null
+    bst.get(6); // null
     expect(bst.get(6)).toBeNull();
-    bst.isAVLBalanced();                            // true or false
+    bst.isAVLBalanced(); // true or false
     expect(bst.isAVLBalanced()).toBe(true);
     const bfsIDs: number[] = [];
     bst.bfs(node => bfsIDs.push(node.key));
-    bfsIDs[0] === 11;                               // true
+    bfsIDs[0] === 11; // true
     expect(bfsIDs[0]).toBe(11);
 
     const objBST = new BST<{ key: number; keyA: number }>();
@@ -57,10 +57,10 @@ describe('Overall BinaryTree Test', () => {
 
     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.isAVLBalanced(); // true
+    expect(avlTree.isAVLBalanced()).toBe(true); // true
     avlTree.delete(10);
-    avlTree.isAVLBalanced();                        // true
-    expect(avlTree.isAVLBalanced()).toBe(true);     // true
+    avlTree.isAVLBalanced(); // true
+    expect(avlTree.isAVLBalanced()).toBe(true); // true
   });
 });

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

@@ -481,7 +481,7 @@ describe('TreeMultiset Performance test', function () {
     }
     isDebug && console.log('---add', performance.now() - start);
     const startL = performance.now();
-    treeMS.lesserOrGreaterTraverse((node) => (node.count += 1), CP.lt, inputSize / 2);
+    treeMS.lesserOrGreaterTraverse(node => (node.count += 1), CP.lt, inputSize / 2);
     isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
   });
 });

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

@@ -40,7 +40,7 @@ describe('DirectedGraph Operation Test', () => {
     graph.addVertex(vertex2);
     graph.addEdge(edge);
 
-    expect(graph.removeEdge(edge)).toBe(edge);
+    expect(graph.deleteEdge(edge)).toBe(edge);
     expect(graph.hasEdge('A', 'B')).toBe(false);
   });
 
@@ -164,7 +164,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     myGraph.addVertex(2, 'data2');
     myGraph.addEdge(1, 2, 10, 'edge-data1-2');
 
-    const removedEdge = myGraph.removeEdgeSrcToDest(1, 2);
+    const removedEdge = myGraph.deleteEdgeSrcToDest(1, 2);
     const edgeAfterRemoval = myGraph.getEdge(1, 2);
 
     expect(removedEdge).toBeInstanceOf(MyEdge);
@@ -233,7 +233,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     expect(myGraph.getEdge(2, 1)).toBeTruthy();
     expect(myGraph.getEdge(1, '100')).toBeFalsy();
 
-    myGraph.removeEdgeSrcToDest(1, 2);
+    myGraph.deleteEdgeSrcToDest(1, 2);
     expect(myGraph.getEdge(1, 2)).toBeFalsy();
 
     myGraph.addEdge(3, 1, 3, 'edge-data-3-1');

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

@@ -20,7 +20,7 @@ describe('Overall Graph Operation Test', () => {
     expect(graph.hasEdge('A', 'B')).toBe(true); // true
     expect(graph.hasEdge('B', 'A')).toBe(false); // false
 
-    graph.removeEdgeSrcToDest('A', 'B');
+    graph.deleteEdgeSrcToDest('A', 'B');
     graph.hasEdge('A', 'B'); // false
     expect(graph.hasEdge('A', 'B')).toBe(false); // false
 
@@ -38,7 +38,7 @@ describe('Overall Graph Operation Test', () => {
     graph.addVertex('B');
     graph.addVertex('C');
     graph.addVertex('D');
-    graph.removeVertex('C');
+    graph.deleteVertex('C');
     graph.addEdge('A', 'B');
     graph.addEdge('B', 'D');
 

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

@@ -40,7 +40,7 @@ describe('UndirectedGraph Operation Test', () => {
     graph.addVertex(vertex2);
     graph.addEdge(edge);
 
-    expect(graph.removeEdge(edge)).toBe(edge);
+    expect(graph.deleteEdge(edge)).toBe(edge);
     expect(graph.hasEdge('A', 'B')).toBe(false);
   });
 
@@ -49,7 +49,7 @@ describe('UndirectedGraph Operation Test', () => {
     graph.addVertex('B');
     graph.addVertex('C');
     graph.addVertex('D');
-    graph.removeVertex('C');
+    graph.deleteVertex('C');
     graph.addEdge('A', 'B');
     graph.addEdge('B', 'D');
 

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

@@ -22,7 +22,7 @@ describe('Heap Operation Test', () => {
   });
 
   it('should object heap work well', function () {
-    const minHeap = new MinHeap<{ a: string; key: number }>((a, b) => a.key - b.key);
+    const minHeap = new MinHeap<{ a: string; key: number }>({comparator: (a, b) => a.key - b.key});
     minHeap.add({key: 1, a: 'a1'});
     minHeap.add({key: 6, a: 'a6'});
     minHeap.add({key: 2, a: 'a2'});
@@ -37,7 +37,7 @@ describe('Heap Operation Test', () => {
       i++;
     }
 
-    const maxHeap = new MaxHeap<{ key: number; a: string }>((a, b) => b.key - a.key);
+    const maxHeap = new MaxHeap<{ key: number; a: string }>({comparator: (a, b) => b.key - a.key});
     maxHeap.add({key: 1, a: 'a1'});
     maxHeap.add({key: 6, a: 'a6'});
     maxHeap.add({key: 5, a: 'a5'});

package/test/unit/data-structures/heap/max-heap.test.ts

@@ -5,7 +5,7 @@ describe('MaxHeap', () => {
   let maxHeap: MaxHeap<number>;
 
   beforeEach(() => {
-    maxHeap = new MaxHeap(numberComparator);
+    maxHeap = new MaxHeap({comparator: numberComparator});
   });
 
   test('add and poll elements in descending order', () => {

package/test/unit/data-structures/heap/min-heap.test.ts

@@ -5,7 +5,7 @@ describe('MinHeap', () => {
   let minHeap: MinHeap<number>;
 
   beforeEach(() => {
-    minHeap = new MinHeap(numberComparator);
+    minHeap = new MinHeap({comparator: numberComparator});
   });
 
   test('add and poll elements in ascending order', () => {