data-structure-typed 1.38.0 → 1.38.2

package/dist/{data-structures → cjs/data-structures}/heap/heap.d.ts

@@ -9,6 +9,22 @@ export declare class Heap<E> {
     protected nodes: E[];
     protected readonly comparator: Comparator<E>;
     constructor(comparator: Comparator<E>);
+    /**
+     * Get the size (number of elements) of the heap.
+     */
+    get size(): number;
+    /**
+     * Get the last element in the heap, which is not necessarily a leaf node.
+     * @returns The last element or undefined if the heap is empty.
+     */
+    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.
+     */
+    static heapify<E>(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.
@@ -29,34 +45,11 @@ export declare class Heap<E> {
      * @returns The top element or undefined if the heap is empty.
      */
     pop(): E | undefined;
-    /**
-     * Float operation to maintain heap properties after adding an element.
-     * @param index - The index of the newly added element.
-     */
-    protected bubbleUp(index: number): void;
-    /**
-     * Sinking operation to maintain heap properties after removing the top element.
-     * @param index - The index from which to start sinking.
-     */
-    protected sinkDown(index: number): void;
-    /**
-     * Fix the entire heap to maintain heap properties.
-     */
-    protected fix(): void;
     /**
      * Peek at the top element of the heap without removing it.
      * @returns The top element or undefined if the heap is empty.
      */
     peek(): E | undefined;
-    /**
-     * Get the size (number of elements) of the heap.
-     */
-    get size(): number;
-    /**
-     * Get the last element in the heap, which is not necessarily a leaf node.
-     * @returns The last element or undefined if the heap is empty.
-     */
-    get leaf(): E | undefined;
     /**
      * Check if the heap is empty.
      * @returns True if the heap is empty, otherwise false.
@@ -100,12 +93,19 @@ export declare class Heap<E> {
      */
     sort(): 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.
+     * Float operation to maintain heap properties after adding an element.
+     * @param index - The index of the newly added element.
      */
-    static heapify<E>(nodes: E[], comparator: Comparator<E>): Heap<E>;
+    protected bubbleUp(index: number): void;
+    /**
+     * Sinking operation to maintain heap properties after removing the top element.
+     * @param index - The index from which to start sinking.
+     */
+    protected sinkDown(index: number): void;
+    /**
+     * Fix the entire heap to maintain heap properties.
+     */
+    protected fix(): void;
 }
 export declare class FibonacciHeapNode<E> {
     element: E;
@@ -119,33 +119,15 @@ export declare class FibonacciHeapNode<E> {
 }
 export declare class FibonacciHeap<E> {
     root?: FibonacciHeapNode<E>;
-    protected min?: FibonacciHeapNode<E>;
     size: number;
+    protected min?: FibonacciHeapNode<E>;
     protected readonly comparator: Comparator<E>;
     constructor(comparator?: Comparator<E>);
-    /**
-     * Default comparator function used by the heap.
-     * @param {E} a
-     * @param {E} b
-     * @protected
-     */
-    protected defaultComparator(a: E, b: E): number;
     /**
      * Get the size (number of elements) of the heap.
      * @returns {number} The size of the heap.  Returns 0 if the heap is empty. Returns -1 if the heap is invalid.
      */
     clear(): void;
-    /**
-     * Create a new node.
-     * @param element
-     * @protected
-     */
-    protected createNode(element: E): FibonacciHeapNode<E>;
-    /**
-     * Merge the given node with the root list.
-     * @param node - The node to be merged.
-     */
-    protected mergeWithRoot(node: FibonacciHeapNode<E>): void;
     /**
      * O(1) time operation.
      * Insert an element into the heap and maintain the heap properties.
@@ -175,13 +157,6 @@ export declare class FibonacciHeap<E> {
      * @returns FibonacciHeapNode<E>[] - An array containing the nodes of the linked list.
      */
     consumeLinkedList(head?: FibonacciHeapNode<E>): FibonacciHeapNode<E>[];
-    /**
-     * O(log n) time operation.
-     * Remove and return the top element (smallest or largest element) from the heap.
-     * @param node - The node to be removed.
-     * @protected
-     */
-    protected removeFromRoot(node: FibonacciHeapNode<E>): void;
     /**
      * O(log n) time operation.
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -192,33 +167,58 @@ export declare class FibonacciHeap<E> {
     /**
      * O(log n) time operation.
      * Remove and return the top element (smallest or largest element) from the heap.
-     * @param y
-     * @param x
-     * @protected
+     * @returns The top element or undefined if the heap is empty.
      */
-    protected link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void;
+    poll(): E | undefined;
     /**
      * O(log n) time operation.
      * Remove and return the top element (smallest or largest element) from the heap.
+     * @returns The top element or undefined if the heap is empty.
+     */
+    pop(): E | undefined;
+    /**
+     * O(log n) time operation.
+     * merge two heaps. The heap that is merged will be cleared. The heap that is merged into will remain.
+     * @param heapToMerge
+     */
+    merge(heapToMerge: FibonacciHeap<E>): void;
+    /**
+     * Default comparator function used by the heap.
+     * @param {E} a
+     * @param {E} b
      * @protected
      */
-    protected consolidate(): void;
+    protected defaultComparator(a: E, b: E): number;
+    /**
+     * Create a new node.
+     * @param element
+     * @protected
+     */
+    protected createNode(element: E): FibonacciHeapNode<E>;
+    /**
+     * Merge the given node with the root list.
+     * @param node - The node to be merged.
+     */
+    protected mergeWithRoot(node: FibonacciHeapNode<E>): void;
     /**
      * O(log n) time operation.
      * Remove and return the top element (smallest or largest element) from the heap.
-     * @returns The top element or undefined if the heap is empty.
+     * @param node - The node to be removed.
+     * @protected
      */
-    poll(): E | undefined;
+    protected removeFromRoot(node: FibonacciHeapNode<E>): void;
     /**
      * O(log n) time operation.
      * Remove and return the top element (smallest or largest element) from the heap.
-     * @returns The top element or undefined if the heap is empty.
+     * @param y
+     * @param x
+     * @protected
      */
-    pop(): E | undefined;
+    protected link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void;
     /**
      * O(log n) time operation.
-     * merge two heaps. The heap that is merged will be cleared. The heap that is merged into will remain.
-     * @param heapToMerge
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @protected
      */
-    merge(heapToMerge: FibonacciHeap<E>): void;
+    protected consolidate(): void;
 }

package/{lib → dist/cjs}/data-structures/linked-list/doubly-linked-list.d.ts

@@ -35,6 +35,7 @@ export declare class DoublyLinkedList<E = any> {
     set tail(value: DoublyLinkedListNode<E> | null);
     private _length;
     get length(): number;
+    get size(): number;
     /**
      * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
      * given array.
@@ -98,7 +99,6 @@ export declare class DoublyLinkedList<E = any> {
      * @returns The method `peekLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
      */
     peekLast(): E | undefined;
-    get size(): number;
     /**
      * The `getAt` function returns the value at a specified index in a linked list, or null if the index is out of bounds.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to

package/dist/{data-structures → cjs/data-structures}/linked-list/skip-linked-list.d.ts

@@ -12,18 +12,6 @@ export declare class SkipListNode<K, V> {
     constructor(key: K, value: V, level: number);
 }
 export declare class SkipList<K, V> {
-    get probability(): number;
-    set probability(value: number);
-    get maxLevel(): number;
-    set maxLevel(value: number);
-    get level(): number;
-    set level(value: number);
-    get head(): SkipListNode<K, V>;
-    set head(value: SkipListNode<K, V>);
-    private _head;
-    private _level;
-    private _maxLevel;
-    private _probability;
     /**
      * The constructor initializes a SkipList with a specified maximum level and probability.
      * @param [maxLevel=16] - The `maxLevel` parameter represents the maximum level that a skip list can have. It determines
@@ -32,11 +20,18 @@ export declare class SkipList<K, V> {
      * level in the skip list. It is used to determine the height of each node in the skip list.
      */
     constructor(maxLevel?: number, probability?: number);
-    /**
-     * The function "randomLevel" generates a random level based on a given probability and maximum level.
-     * @returns the level, which is a number.
-     */
-    private randomLevel;
+    private _head;
+    get head(): SkipListNode<K, V>;
+    set head(value: SkipListNode<K, V>);
+    private _level;
+    get level(): number;
+    set level(value: number);
+    private _maxLevel;
+    get maxLevel(): number;
+    set maxLevel(value: number);
+    private _probability;
+    get probability(): number;
+    set probability(value: number);
     /**
      * The add function adds a new node with a given key and value to a Skip List data structure.
      * @param {K} key - The key parameter represents the key of the node that needs to be added to the skip list.
@@ -58,4 +53,9 @@ export declare class SkipList<K, V> {
      * skip list, and `false` if the key was not found in the skip list.
      */
     delete(key: K): boolean;
+    /**
+     * The function "randomLevel" generates a random level based on a given probability and maximum level.
+     * @returns the level, which is a number.
+     */
+    private randomLevel;
 }

package/{lib → dist/cjs}/data-structures/matrix/matrix2d.d.ts

@@ -31,13 +31,6 @@ export declare class Matrix2D {
      * array of numbers.
      */
     get m(): number[][];
-    /**
-     * The function "toVector" returns a new Vector2D object with the values from the first and second elements of the
-     * _matrix array.
-     * @returns A new instance of the Vector2D class is being returned. The values of the returned vector are taken from
-     * the first column of the matrix.
-     */
-    toVector(): Vector2D;
     /**
      * The function takes two 2D matrices as input and returns their sum as a new 2D matrix.
      * @param {Matrix2D} matrix1 - Matrix2D - The first matrix to be added.
@@ -104,5 +97,12 @@ export declare class Matrix2D {
      * @returns The method is returning a new instance of the Matrix2D class.
      */
     static translate(vector: Vector2D): Matrix2D;
+    /**
+     * The function "toVector" returns a new Vector2D object with the values from the first and second elements of the
+     * _matrix array.
+     * @returns A new instance of the Vector2D class is being returned. The values of the returned vector are taken from
+     * the first column of the matrix.
+     */
+    toVector(): Vector2D;
 }
 export default Matrix2D;

package/{lib → dist/cjs}/data-structures/trie/trie.d.ts

@@ -25,11 +25,11 @@ export declare class TrieNode {
  * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
  */
 export declare class Trie {
+    private readonly _caseSensitive;
     constructor(words?: string[], caseSensitive?: boolean);
     protected _root: TrieNode;
     get root(): TrieNode;
     set root(v: TrieNode);
-    private readonly _caseSensitive;
     /**
      * Add a word to the Trie structure.
      * @param {string} word - The word to add.
@@ -42,7 +42,6 @@ export declare class Trie {
      * @returns {boolean} True if the word is present in the Trie.
      */
     has(word: string): boolean;
-    private _caseProcess;
     /**
      * Remove a word from the Trie structure.
      * @param{string} word - The word to delete.
@@ -81,4 +80,5 @@ export declare class Trie {
      * @returns {string[]} an array of strings.
      */
     getWords(prefix?: string, max?: number): string[];
+    private _caseProcess;
 }