linked-list-typed 1.45.3 → 1.46.2

package/dist/types/data-structures/hash/hash-map.d.ts

@@ -1,12 +1,3 @@
-export declare const enum IterateDirection {
-    DEFAULT = 0,
-    REVERSE = 1
-}
-export type HashMapOptions<T> = {
-    sizeFunction?: number | (() => number);
-    fixedLength?: number;
-    forEach: (callback: (el: T) => void) => void;
-};
 export type HashMapLinkedNode<K, V> = {
     key: K;
     value: V;

package/dist/types/helpers.d.ts

@@ -6,3 +6,14 @@ export declare enum CP {
     eq = "eq",
     gt = "gt"
 }
+export declare const enum IterateDirection {
+    DEFAULT = 0,
+    REVERSE = 1
+}
+export interface IterableWithSize<T> extends Iterable<T> {
+    size: number | ((...args: any[]) => number);
+}
+export interface IterableWithLength<T> extends Iterable<T> {
+    length: number | ((...args: any[]) => number);
+}
+export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>;

package/dist/utils/utils.d.ts

@@ -21,3 +21,4 @@ export declare const getMSB: (value: number) => number;
 export declare const rangeCheck: (index: number, min: number, max: number, message?: string) => void;
 export declare const throwRangeError: (message?: string) => void;
 export declare const isObjOrFunc: (input: unknown) => input is Record<string, unknown> | ((...args: any[]) => any);
+export declare const calcMinUnitsRequired: (totalQuantity: number, unitSize: number) => number;

package/dist/utils/utils.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isObjOrFunc = exports.throwRangeError = exports.rangeCheck = exports.getMSB = exports.trampolineAsync = exports.trampoline = exports.toThunk = exports.isThunk = exports.THUNK_SYMBOL = exports.arrayRemove = exports.uuidV4 = void 0;
+exports.calcMinUnitsRequired = exports.isObjOrFunc = exports.throwRangeError = exports.rangeCheck = exports.getMSB = exports.trampolineAsync = exports.trampoline = exports.toThunk = exports.isThunk = exports.THUNK_SYMBOL = exports.arrayRemove = exports.uuidV4 = void 0;
 const uuidV4 = function () {
     return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
         const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
@@ -85,3 +85,5 @@ const isObjOrFunc = (input) => {
     return (inputType === 'object' && input !== null) || inputType === 'function';
 };
 exports.isObjOrFunc = isObjOrFunc;
+const calcMinUnitsRequired = (totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize);
+exports.calcMinUnitsRequired = calcMinUnitsRequired;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-list-typed",
-  "version": "1.45.3",
+  "version": "1.46.2",
   "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.45.3"
+    "data-structure-typed": "^1.46.2"
   }
 }

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

@@ -7,7 +7,7 @@
  */
 
 import { isObjOrFunc, rangeCheck, throwRangeError } from '../../utils';
-import { HashMapLinkedNode, HashMapOptions, IterateDirection } from '../../types';
+import { HashMapLinkedNode, IterableWithSizeOrLength, IterateDirection } from '../../types';
 
 /**
  * Because the implementation of HashMap relies on JavaScript's built-in objects and arrays,
@@ -122,6 +122,10 @@ export class HashMapIterator<K, V> {
   next() {
     return this;
   }
+
+  clone() {
+    return new HashMapIterator<K, V>(this._node, this._sentinel, this.hashMap, this.iterateDirection)
+  }
 }
 
 export class HashMap<K = any, V = any> {
@@ -134,18 +138,18 @@ export class HashMap<K = any, V = any> {
 
   /**
    * The constructor initializes a HashMap object with an optional initial set of key-value pairs.
-   * @param hashMap - The `hashMap` parameter is an optional parameter of type `HashMapOptions<[K,
+   * @param {Iterable<[K, V]>} elements - The `hashMap` parameter is an optional parameter of type `HashMapOptions<[K,
    * V]>`. It is an array of key-value pairs, where each pair is represented as an array `[K, V]`. The
    * `K` represents the type of the key and `V` represents the
    */
-  constructor(hashMap: HashMapOptions<[K, V]> = []) {
+  constructor(elements: IterableWithSizeOrLength<[K, V]> = []) {
     Object.setPrototypeOf(this._orgMap, null);
     this._sentinel = <HashMapLinkedNode<K, V>>{};
     this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
 
-    hashMap.forEach(el => {
+    for (const el of elements) {
       this.set(el[0], el[1]);
-    });
+    }
   }
 
   protected _size = 0;
@@ -209,7 +213,7 @@ export class HashMap<K = any, V = any> {
    * @returns The front element of the data structure, represented as a tuple with a key (K) and a
    * value (V).
    */
-  get front() {
+  get first() {
     if (this._size === 0) return;
     return <[K, V]>[this._head.key, this._head.value];
   }
@@ -222,7 +226,7 @@ export class HashMap<K = any, V = any> {
    * @returns The method is returning an array containing the key-value pair of the tail element in the
    * data structure.
    */
-  get back() {
+  get last() {
     if (this._size === 0) return;
     return <[K, V]>[this._tail.key, this._tail.value];
   }

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

@@ -8,18 +8,18 @@
 import type { Comparator, DFSOrderPattern } from '../../types';
 
 export class Heap<E = any> {
-  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
+  constructor(options: { comparator: Comparator<E>; elements?: E[] }) {
     this._comparator = options.comparator;
-    if (options.nodes && options.nodes.length > 0) {
-      this._nodes = options.nodes;
+    if (options.elements && options.elements.length > 0) {
+      this._elements = options.elements;
       this.fix();
     }
   }
 
-  protected _nodes: E[] = [];
+  protected _elements: E[] = [];
 
-  get nodes(): E[] {
-    return this._nodes;
+  get elements(): E[] {
+    return this._elements;
   }
 
   protected _comparator: Comparator<E>;
@@ -32,7 +32,7 @@ export class Heap<E = any> {
    * Get the size (number of elements) of the heap.
    */
   get size(): number {
-    return this.nodes.length;
+    return this.elements.length;
   }
 
   /**
@@ -40,25 +40,25 @@ export class Heap<E = any> {
    * @returns The last element or undefined if the heap is empty.
    */
   get leaf(): E | undefined {
-    return this.nodes[this.size - 1] ?? undefined;
+    return this.elements[this.size - 1] ?? undefined;
   }
 
   /**
-   * Static method that creates a binary heap from an array of nodes and a comparison function.
+   * Static method that creates a binary heap from an array of elements and a comparison function.
    * @returns A new Heap instance.
    * @param options
    */
-  static heapify<E>(options: { nodes: E[]; comparator: Comparator<E> }): Heap<E> {
+  static heapify<E>(options: { elements: E[]; comparator: Comparator<E> }): Heap<E> {
     return new Heap<E>(options);
   }
 
   /**
-   * Time Complexity: O(log n), where n is the number of nodes in the heap.
+   * Time Complexity: O(log n), where n is the number of elements in the heap.
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n), where n is the number of nodes in the heap.
+   * Time Complexity: O(log n), where n is the number of elements in the heap.
    * Space Complexity: O(1)
    *
    * Insert an element into the heap and maintain the heap properties.
@@ -69,56 +69,53 @@ export class Heap<E = any> {
   }
 
   /**
-   * Time Complexity: O(log n), where n is the number of nodes in the heap.
+   * Time Complexity: O(log n), where n is the number of elements in the heap.
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n), where n is the number of nodes in the heap.
+   * Time Complexity: O(log n), where n is the number of elements in the heap.
    * Space Complexity: O(1)
    *
    * Insert an element into the heap and maintain the heap properties.
    * @param element - The element to be inserted.
    */
   push(element: E): Heap<E> {
-    this.nodes.push(element);
-    this.bubbleUp(this.nodes.length - 1);
+    this._elements.push(element);
+    this._bubbleUp(this.elements.length - 1);
     return this;
   }
 
   /**
-   * Time Complexity: O(log n), where n is the number of nodes in the heap.
+   * Time Complexity: O(log n), where n is the number of elements in the heap.
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n), where n is the number of nodes in the heap.
+   * Time Complexity: O(log n), where n is the number of elements in the heap.
    * Space Complexity: O(1)
    *
    * Remove and return the top element (smallest or largest element) from the heap.
    * @returns The top element or undefined if the heap is empty.
    */
   poll(): E | undefined {
-    if (this.nodes.length === 0) {
-      return undefined;
+    if (this.elements.length === 0) return;
+    const value = this.elements[0];
+    const last = this.elements.pop()!;
+    if (this.elements.length) {
+      this.elements[0] = last;
+      this._sinkDown(0, this.elements.length >> 1);
     }
-    if (this.nodes.length === 1) {
-      return this.nodes.pop() as E;
-    }
-
-    const topValue = this.nodes[0];
-    this.nodes[0] = this.nodes.pop() as E;
-    this.sinkDown(0);
-    return topValue;
+    return value;
   }
 
   /**
-   * Time Complexity: O(log n), where n is the number of nodes in the heap.
+   * Time Complexity: O(log n), where n is the number of elements in the heap.
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n), where n is the number of nodes in the heap.
+   * Time Complexity: O(log n), where n is the number of elements in the heap.
    * Space Complexity: O(1)
    *
    * Remove and return the top element (smallest or largest element) from the heap.
@@ -133,10 +130,7 @@ export class Heap<E = any> {
    * @returns The top element or undefined if the heap is empty.
    */
   peek(): E | undefined {
-    if (this.nodes.length === 0) {
-      return undefined;
-    }
-    return this.nodes[0];
+    return this.elements[0];
   }
 
   /**
@@ -148,36 +142,36 @@ export class Heap<E = any> {
   }
 
   /**
-   * Reset the nodes of the heap. Make the nodes empty.
+   * Reset the elements of the heap. Make the elements empty.
    */
   clear() {
-    this._nodes = [];
+    this._elements = [];
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the nodes array.
+   * Time Complexity: O(n), where n is the number of elements in the elements array.
    * Space Complexity: O(n)
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the nodes array.
+   * Time Complexity: O(n), where n is the number of elements in the elements array.
    * Space Complexity: O(n)
    *
-   * Clear and add nodes of the heap
-   * @param nodes
+   * Clear and add elements of the heap
+   * @param elements
    */
-  refill(nodes: E[]) {
-    this._nodes = nodes;
+  refill(elements: E[]) {
+    this._elements = elements;
     this.fix();
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of nodes in the heap.
+   * Time Complexity: O(n), where n is the number of elements in the heap.
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of nodes in the heap.
+   * Time Complexity: O(n), where n is the number of elements in the heap.
    * Space Complexity: O(1)
    *
    * Use a comparison function to check whether a binary heap contains a specific element.
@@ -185,16 +179,47 @@ export class Heap<E = any> {
    * @returns Returns true if the specified element is contained; otherwise, returns false.
    */
   has(element: E): boolean {
-    return this.nodes.includes(element);
+    return this.elements.includes(element);
+  }
+
+  /**
+   * Time Complexity:  O(n). The worst-case  O(n), where n is the number of elements in the heap. This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity:  O(n). The worst-case  O(n), where n is the number of elements in the heap. This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
+   * Space Complexity: O(1)
+   *
+   * The `delete` function removes an element from an array-like data structure, maintaining the order
+   * and structure of the remaining elements.
+   * @param {E} element - The `element` parameter represents the element that you want to delete from
+   * the array `this.elements`.
+   * @returns The `delete` function is returning a boolean value. It returns `true` if the element was
+   * successfully deleted from the array, and `false` if the element was not found in the array.
+   */
+  delete(element: E) {
+    const index = this.elements.indexOf(element);
+    if (index < 0) return false;
+    if (index === 0) {
+      this.pop();
+    } else if (index === this.elements.length - 1) {
+      this.elements.pop();
+    } else {
+      this.elements.splice(index, 1, this.elements.pop()!);
+      this._bubbleUp(index);
+      this._sinkDown(index, this.elements.length >> 1);
+    }
+    return true;
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of nodes in the heap.
+   * Time Complexity: O(n), where n is the number of elements in the heap.
    * Space Complexity: O(h), where h is the height of the heap.
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of nodes in the heap.
+   * Time Complexity: O(n), where n is the number of elements in the heap.
    * Space Complexity: O(h), where h is the height of the heap.
    *
    * Depth-first search (DFS) method, different traversal orders can be selected。
@@ -209,16 +234,16 @@ export class Heap<E = any> {
       if (index < this.size) {
         if (order === 'in') {
           dfsHelper(2 * index + 1);
-          result.push(this.nodes[index]);
+          result.push(this.elements[index]);
           dfsHelper(2 * index + 2);
         } else if (order === 'pre') {
-          result.push(this.nodes[index]);
+          result.push(this.elements[index]);
           dfsHelper(2 * index + 1);
           dfsHelper(2 * index + 2);
         } else if (order === 'post') {
           dfsHelper(2 * index + 1);
           dfsHelper(2 * index + 2);
-          result.push(this.nodes[index]);
+          result.push(this.elements[index]);
         }
       }
     };
@@ -241,15 +266,7 @@ export class Heap<E = any> {
    * @returns An array containing the elements of the heap.
    */
   toArray(): E[] {
-    return [...this.nodes];
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-  getNodes(): E[] {
-    return this.nodes;
+    return [...this.elements];
   }
 
   /**
@@ -266,7 +283,7 @@ export class Heap<E = any> {
    */
   clone(): Heap<E> {
     const clonedHeap = new Heap<E>({ comparator: this.comparator });
-    clonedHeap._nodes = [...this.nodes];
+    clonedHeap._elements = [...this.elements];
     return clonedHeap;
   }
 
@@ -298,35 +315,13 @@ export class Heap<E = any> {
    */
 
   /**
-   * Time Complexity: O(log n)
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
-   * Float operation to maintain heap properties after adding an element.
-   * @param index - The index of the newly added element.
+   * Fix the entire heap to maintain heap properties.
    */
-  protected bubbleUp(index: number): void {
-    // const element = this.nodes[index];
-    // while (index > 0) {
-    //   const parentIndex = (index - 1) >> 1;
-    //   const parent = this.nodes[parentIndex];
-    //   if (this.comparator(element, parent) < 0) {
-    //     this.nodes[index] = parent;
-    //     this.nodes[parentIndex] = element;
-    //     index = parentIndex;
-    //   } else {
-    //     break;
-    //   }
-    // }
-
-    const item = this.nodes[index];
-    while (index > 0) {
-      const parent = (index - 1) >> 1;
-      const parentItem = this.nodes[parent];
-      if (this.comparator(parentItem, item) <= 0) break;
-      this.nodes[index] = parentItem;
-      index = parent;
-    }
-    this.nodes[index] = item;
+  fix() {
+    for (let i = Math.floor(this.size / 2); i >= 0; i--) this._sinkDown(i, this.elements.length >> 1);
   }
 
   /**
@@ -338,28 +333,19 @@ export class Heap<E = any> {
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
    *
-   * Sinking operation to maintain heap properties after removing the top element.
-   * @param index - The index from which to start sinking.
+   * Float operation to maintain heap properties after adding an element.
+   * @param index - The index of the newly added element.
    */
-  protected sinkDown(index: number): void {
-    const leftChildIndex = index << 1 | 1;
-    const rightChildIndex = leftChildIndex + 1;
-    const length = this.nodes.length;
-    let targetIndex = index;
-
-    if (leftChildIndex < length && this.comparator(this.nodes[leftChildIndex], this.nodes[targetIndex]) < 0) {
-      targetIndex = leftChildIndex;
-    }
-    if (rightChildIndex < length && this.comparator(this.nodes[rightChildIndex], this.nodes[targetIndex]) < 0) {
-      targetIndex = rightChildIndex;
-    }
-
-    if (targetIndex !== index) {
-      const temp = this.nodes[index];
-      this.nodes[index] = this.nodes[targetIndex];
-      this.nodes[targetIndex] = temp;
-      this.sinkDown(targetIndex);
+  protected _bubbleUp(index: number) {
+    const element = this.elements[index];
+    while (index > 0) {
+      const parent = (index - 1) >> 1;
+      const parentItem = this.elements[parent];
+      if (this._comparator(parentItem, element) <= 0) break;
+      this.elements[index] = parentItem;
+      index = parent;
     }
+    this.elements[index] = element;
   }
 
   /**
@@ -368,13 +354,31 @@ export class Heap<E = any> {
    */
 
   /**
-   * Time Complexity: O(n)
+   * Time Complexity: O(log n)
    * Space Complexity: O(1)
    *
-   * Fix the entire heap to maintain heap properties.
-   */
-  protected fix() {
-    for (let i = Math.floor(this.size / 2); i >= 0; i--) this.sinkDown(i);
+   * Sinking operation to maintain heap properties after removing the top element.
+   * @param index - The index from which to start sinking.
+   * @param halfLength
+   */
+  protected _sinkDown(index: number, halfLength: number) {
+    const element = this.elements[index];
+    while (index < halfLength) {
+      let left = index << 1 | 1;
+      const right = left + 1;
+      let minItem = this.elements[left];
+      if (
+        right < this.elements.length &&
+        this._comparator(minItem, this.elements[right]) > 0
+      ) {
+        left = right;
+        minItem = this.elements[right];
+      }
+      if (this._comparator(minItem, element) >= 0) break;
+      this.elements[index] = minItem;
+      index = left;
+    }
+    this.elements[index] = element;
   }
 }
 
@@ -500,22 +504,22 @@ export class FibonacciHeap<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of nodes in the linked list.
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of nodes in the linked list.
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(1)
    *
    * Get the size (number of elements) of the heap.
    * @param {FibonacciHeapNode<E>} head - The head of the linked list.
    * @protected
-   * @returns FibonacciHeapNode<E>[] - An array containing the nodes of the linked list.
+   * @returns FibonacciHeapNode<E>[] - An array containing the elements of the linked list.
    */
   consumeLinkedList(head?: FibonacciHeapNode<E>): FibonacciHeapNode<E>[] {
-    const nodes: FibonacciHeapNode<E>[] = [];
-    if (!head) return nodes;
+    const elements: FibonacciHeapNode<E>[] = [];
+    if (!head) return elements;
 
     let node: FibonacciHeapNode<E> | undefined = head;
     let flag = false;
@@ -525,12 +529,12 @@ export class FibonacciHeap<E> {
       else if (node === head) flag = true;
 
       if (node) {
-        nodes.push(node);
+        elements.push(node);
         node = node.right;
       }
     }
 
-    return nodes;
+    return elements;
   }
 
   /**
@@ -552,12 +556,12 @@ export class FibonacciHeap<E> {
   }
 
   /**
-   * Time Complexity: O(log n), where n is the number of nodes in the heap.
+   * Time Complexity: O(log n), where n is the number of elements in the heap.
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n), where n is the number of nodes in the heap.
+   * Time Complexity: O(log n), where n is the number of elements in the heap.
    * Space Complexity: O(1)
    *
    * Remove and return the top element (smallest or largest element) from the heap.
@@ -568,12 +572,12 @@ export class FibonacciHeap<E> {
   }
 
   /**
-   * Time Complexity: O(log n), where n is the number of nodes in the heap.
+   * Time Complexity: O(log n), where n is the number of elements in the heap.
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n), where n is the number of nodes in the heap.
+   * Time Complexity: O(log n), where n is the number of elements in the heap.
    * Space Complexity: O(1)
    *
    * Remove and return the top element (smallest or largest element) from the heap.
@@ -584,8 +588,8 @@ export class FibonacciHeap<E> {
 
     const z = this.min!;
     if (z.child) {
-      const nodes = this.consumeLinkedList(z.child);
-      for (const node of nodes) {
+      const elements = this.consumeLinkedList(z.child);
+      for (const node of elements) {
         this.mergeWithRoot(node);
         node.parent = undefined;
       }
@@ -737,12 +741,12 @@ export class FibonacciHeap<E> {
   }
 
   /**
-   * Time Complexity: O(n log n), where n is the number of nodes in the heap.
+   * Time Complexity: O(n log n), where n is the number of elements in the heap.
    * Space Complexity: O(n)
    */
 
   /**
-   * Time Complexity: O(n log n), where n is the number of nodes in the heap.
+   * Time Complexity: O(n log n), where n is the number of elements in the heap.
    * Space Complexity: O(n)
    *
    * Remove and return the top element (smallest or largest element) from the heap.
@@ -750,13 +754,13 @@ export class FibonacciHeap<E> {
    */
   protected consolidate(): void {
     const A: (FibonacciHeapNode<E> | undefined)[] = new Array(this.size);
-    const nodes = this.consumeLinkedList(this.root);
+    const elements = this.consumeLinkedList(this.root);
     let x: FibonacciHeapNode<E> | undefined,
       y: FibonacciHeapNode<E> | undefined,
       d: number,
       t: FibonacciHeapNode<E> | undefined;
 
-    for (const node of nodes) {
+    for (const node of elements) {
       x = node;
       d = x.degree;