linked-list-typed 1.38.9 → 1.39.1

package/dist/data-structures/heap/heap.d.ts

@@ -5,10 +5,13 @@
  * @license MIT License
  */
 import type { Comparator, DFSOrderPattern } from '../../types';
-export declare class Heap<E> {
+export declare class Heap<E = any> {
     protected nodes: E[];
     protected readonly comparator: Comparator<E>;
-    constructor(comparator: Comparator<E>);
+    constructor(options: {
+        comparator: Comparator<E>;
+        nodes?: E[];
+    });
     /**
      * Get the size (number of elements) of the heap.
      */
@@ -20,11 +23,13 @@ export declare class Heap<E> {
     get leaf(): E | undefined;
     /**
      * 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>;
+    static heapify<E>(options: {
+        nodes: E[];
+        comparator: Comparator<E>;
+    }): Heap<E>;
     /**
      * Insert an element into the heap and maintain the heap properties.
      * @param element - The element to be inserted.

package/dist/data-structures/heap/heap.js

@@ -8,9 +8,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FibonacciHeap = exports.FibonacciHeapNode = exports.Heap = void 0;
 class Heap {
-    constructor(comparator) {
+    constructor(options) {
         this.nodes = [];
-        this.comparator = comparator;
+        this.comparator = options.comparator;
+        if (options.nodes && options.nodes.length > 0) {
+            this.nodes = options.nodes;
+            this.fix();
+        }
     }
     /**
      * Get the size (number of elements) of the heap.
@@ -28,15 +32,11 @@ class Heap {
     }
     /**
      * 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(nodes, comparator) {
-        const binaryHeap = new Heap(comparator);
-        binaryHeap.nodes = [...nodes];
-        binaryHeap.fix(); // Fix heap properties
-        return binaryHeap;
+    static heapify(options) {
+        return new Heap(options);
     }
     /**
      * Insert an element into the heap and maintain the heap properties.
@@ -161,7 +161,7 @@ class Heap {
      * @returns A new Heap instance containing the same elements.
      */
     clone() {
-        const clonedHeap = new Heap(this.comparator);
+        const clonedHeap = new Heap({ comparator: this.comparator });
         clonedHeap.nodes = [...this.nodes];
         return clonedHeap;
     }

package/dist/data-structures/heap/max-heap.d.ts

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

package/dist/data-structures/heap/max-heap.js

@@ -10,15 +10,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxHeap = void 0;
 const heap_1 = require("./heap");
 class MaxHeap extends heap_1.Heap {
-    constructor(comparator = (a, b) => {
-        if (!(typeof a === 'number' && typeof b === 'number')) {
-            throw new Error('The a, b params of compare function must be number');
-        }
-        else {
-            return b - a;
+    constructor(options = {
+        comparator: (a, b) => {
+            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);
     }
 }
 exports.MaxHeap = MaxHeap;

package/dist/data-structures/heap/min-heap.d.ts

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

package/dist/data-structures/heap/min-heap.js

@@ -10,15 +10,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinHeap = void 0;
 const heap_1 = require("./heap");
 class MinHeap extends heap_1.Heap {
-    constructor(comparator = (a, b) => {
-        if (!(typeof a === 'number' && typeof b === 'number')) {
-            throw new Error('The a, b params of compare function must be number');
-        }
-        else {
-            return a - b;
+    constructor(options = {
+        comparator: (a, b) => {
+            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);
     }
 }
 exports.MinHeap = MinHeap;

package/dist/data-structures/matrix/matrix2d.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import Vector2D from './vector2d';
+import { Vector2D } from './vector2d';
 export declare class Matrix2D {
     private readonly _matrix;
     /**
@@ -105,4 +105,3 @@ export declare class Matrix2D {
      */
     toVector(): Vector2D;
 }
-export default Matrix2D;

package/dist/data-structures/matrix/matrix2d.js

@@ -1,7 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Matrix2D = void 0;
 /**
@@ -11,7 +8,7 @@ exports.Matrix2D = void 0;
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-const vector2d_1 = __importDefault(require("./vector2d"));
+const vector2d_1 = require("./vector2d");
 class Matrix2D {
     /**
      * The constructor function initializes a Matrix2D object with either a default identity matrix, or a provided matrix
@@ -23,7 +20,7 @@ class Matrix2D {
         if (typeof value === 'undefined') {
             this._matrix = Matrix2D.identity;
         }
-        else if (value instanceof vector2d_1.default) {
+        else if (value instanceof vector2d_1.Vector2D) {
             this._matrix = Matrix2D.identity;
             this._matrix[0][0] = value.x;
             this._matrix[1][0] = value.y;
@@ -196,8 +193,7 @@ class Matrix2D {
      * the first column of the matrix.
      */
     toVector() {
-        return new vector2d_1.default(this._matrix[0][0], this._matrix[1][0]);
+        return new vector2d_1.Vector2D(this._matrix[0][0], this._matrix[1][0]);
     }
 }
 exports.Matrix2D = Matrix2D;
-exports.default = Matrix2D;

package/dist/data-structures/matrix/vector2d.d.ts

@@ -198,4 +198,3 @@ export declare class Vector2D {
      */
     zero(): void;
 }
-export default Vector2D;

package/dist/data-structures/matrix/vector2d.js

@@ -288,4 +288,3 @@ class Vector2D {
     }
 }
 exports.Vector2D = Vector2D;
-exports.default = Vector2D;

package/dist/data-structures/priority-queue/max-priority-queue.d.ts

@@ -8,5 +8,8 @@
 import { PriorityQueue } from './priority-queue';
 import type { Comparator } from '../../types';
 export declare class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
-    constructor(compare?: Comparator<E>);
+    constructor(options?: {
+        comparator: Comparator<E>;
+        nodes?: E[];
+    });
 }

package/dist/data-structures/priority-queue/max-priority-queue.js

@@ -10,15 +10,17 @@ exports.MaxPriorityQueue = void 0;
  */
 const priority_queue_1 = require("./priority-queue");
 class MaxPriorityQueue extends priority_queue_1.PriorityQueue {
-    constructor(compare = (a, b) => {
-        if (!(typeof a === 'number' && typeof b === 'number')) {
-            throw new Error('The a, b params of compare function must be number');
-        }
-        else {
-            return b - a;
+    constructor(options = {
+        comparator: (a, b) => {
+            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);
     }
 }
 exports.MaxPriorityQueue = MaxPriorityQueue;

package/dist/data-structures/priority-queue/min-priority-queue.d.ts

@@ -8,5 +8,8 @@
 import { PriorityQueue } from './priority-queue';
 import type { Comparator } from '../../types';
 export declare class MinPriorityQueue<E = any> extends PriorityQueue<E> {
-    constructor(compare?: Comparator<E>);
+    constructor(options?: {
+        comparator: Comparator<E>;
+        nodes?: E[];
+    });
 }

package/dist/data-structures/priority-queue/min-priority-queue.js

@@ -10,15 +10,17 @@ exports.MinPriorityQueue = void 0;
  */
 const priority_queue_1 = require("./priority-queue");
 class MinPriorityQueue extends priority_queue_1.PriorityQueue {
-    constructor(compare = (a, b) => {
-        if (!(typeof a === 'number' && typeof b === 'number')) {
-            throw new Error('The a, b params of compare function must be number');
-        }
-        else {
-            return a - b;
+    constructor(options = {
+        comparator: (a, b) => {
+            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);
     }
 }
 exports.MinPriorityQueue = MinPriorityQueue;

package/dist/data-structures/priority-queue/priority-queue.d.ts

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

package/dist/data-structures/priority-queue/priority-queue.js

@@ -10,8 +10,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PriorityQueue = void 0;
 const heap_1 = require("../heap");
 class PriorityQueue extends heap_1.Heap {
-    constructor(comparator) {
-        super(comparator);
+    constructor(options) {
+        super(options);
     }
 }
 exports.PriorityQueue = PriorityQueue;

package/dist/interfaces/binary-tree.d.ts

@@ -1,7 +1,7 @@
 import { BinaryTreeNode } from '../data-structures';
-import { BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodeNested, MapCallback } from '../types';
+import { BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodeNested, OneParamCallback } from '../types';
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>> {
     createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
-    delete<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C): BinaryTreeDeletedResult<N>[];
+    delete<C extends OneParamCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeletedResult<N>[];
 }

package/dist/types/data-structures/binary-tree/binary-tree.d.ts

@@ -19,8 +19,6 @@ export declare enum FamilyPosition {
     MAL_NODE = "MAL_NODE"
 }
 export type BinaryTreeNodeKey = number;
-export type BFSCallback<N, D = any> = (node: N, level?: number) => D;
-export type BFSCallbackReturn<N> = ReturnType<BFSCallback<N>>;
 export type BinaryTreeDeletedResult<N> = {
     deleted: N | null | undefined;
     needBalanced: N | null;

package/dist/types/helpers.d.ts

@@ -1,9 +1,6 @@
-import { BinaryTreeNodeKey } from './data-structures';
 export type Comparator<T> = (a: T, b: T) => number;
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
-export type MapCallback<N, D = any> = (node: N) => D;
-export type DefaultMapCallback<N, D = BinaryTreeNodeKey> = (node: N) => D;
-export type MapCallbackReturn<N> = ReturnType<MapCallback<N>>;
+export type OneParamCallback<N, D = any> = (node: N) => D;
 export declare enum CP {
     lt = "lt",
     eq = "eq",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-list-typed",
-  "version": "1.38.9",
+  "version": "1.39.1",
   "description": "Linked List, Doubly Linked List, Singly Linked List. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -66,6 +66,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.38.9"
+    "data-structure-typed": "^1.39.0"
   }
 }

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

@@ -7,7 +7,7 @@
  */
 import {BST, BSTNode} from './bst';
 import type {AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeletedResult, BinaryTreeNodeKey} from '../../types';
-import {MapCallback} from '../../types';
+import {OneParamCallback} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 
 export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNested<V>> extends BSTNode<V, N> {
@@ -21,7 +21,8 @@ export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNeste
 
 export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>>
   extends BST<V, N>
-  implements IBinaryTree<V, N> {
+  implements IBinaryTree<V, N>
+{
   /**
    * This is a constructor function for an AVL tree data structure in TypeScript.
    * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
@@ -73,7 +74,7 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
    * `this._defaultCallbackByKey`
    * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
    */
-  override delete<C extends MapCallback<N>>(
+  override delete<C extends OneParamCallback<N>>(
     identifier: ReturnType<C>,
     callback: C = this._defaultCallbackByKey as C
   ): BinaryTreeDeletedResult<N>[] {
@@ -160,7 +161,7 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
       // Balance Restoration: If a balance issue is discovered after inserting a node, it requires balance restoration operations. Balance restoration includes four basic cases where rotation operations need to be performed to fix the balance:
       switch (
         this._balanceFactor(A) // second O(1)
-        ) {
+      ) {
         case -2:
           if (A && A.left) {
             if (this._balanceFactor(A.left) <= 0) {

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

@@ -17,7 +17,7 @@ export class BinaryIndexedTree {
    * @param  - - `frequency`: The default frequency value. It is optional and has a default
    * value of 0.
    */
-  constructor({frequency = 0, max}: { frequency?: number; max: number }) {
+  constructor({frequency = 0, max}: {frequency?: number; max: number}) {
     this._freq = frequency;
     this._max = max;
     this._freqMap = {0: 0};
@@ -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.