min-heap-typed 1.50.2 → 1.50.3

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

@@ -51,7 +51,6 @@ class Heap extends base_1.IterableElementBase {
             for (const el of elements) {
                 this.add(el);
             }
-            // this.fix();
         }
     }
     /**
@@ -130,6 +129,10 @@ class Heap extends base_1.IterableElementBase {
         }
         return value;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -154,11 +157,11 @@ class Heap extends base_1.IterableElementBase {
         this._elements = [];
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the elements array.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the elements array.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
      * Clear and add elements of the heap
@@ -169,11 +172,11 @@ class Heap extends base_1.IterableElementBase {
         return this.fix();
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * Use a comparison function to check whether a binary heap contains a specific element.
@@ -184,11 +187,12 @@ class Heap extends base_1.IterableElementBase {
         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.
+     * Time Complexity:  O(n)
      * Space Complexity: O(1)
+     * The worst-case  O(n) 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.
      */
     /**
-     * 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.
+     * Time Complexity:  O(n)
      * Space Complexity: O(1)
      *
      * The `delete` function removes an element from an array-like data structure, maintaining the order
@@ -216,12 +220,13 @@ class Heap extends base_1.IterableElementBase {
         return true;
     }
     /**
-     * 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)
+     * Space Complexity: O(log n)
+     * where log n is the height of 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)
+     * Space Complexity: O(log n)
      *
      * Depth-first search (DFS) method, different traversal orders can be selected。
      * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
@@ -305,12 +310,12 @@ class Heap extends base_1.IterableElementBase {
         return visitedNode;
     }
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      *
      * Fix the entire heap to maintain heap properties.
      */
@@ -393,7 +398,7 @@ class Heap extends base_1.IterableElementBase {
         }
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
@@ -416,6 +421,10 @@ class Heap extends base_1.IterableElementBase {
         this.elements[index] = element;
         return true;
     }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -619,11 +628,11 @@ class FibonacciHeap {
         }
     }
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -633,11 +642,11 @@ class FibonacciHeap {
         return this.pop();
     }
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -8,15 +8,51 @@
 import type { ElementCallback } from '../../types';
 import { IterableElementBase } from '../base';
 export declare class DoublyLinkedListNode<E = any> {
-    value: E;
-    next: DoublyLinkedListNode<E> | undefined;
-    prev: DoublyLinkedListNode<E> | undefined;
     /**
      * The constructor function initializes the value, next, and previous properties of an object.
      * @param {E} value - The "value" parameter is the value that will be stored in the node. It can be of any data type, as it
      * is defined as a generic type "E".
      */
     constructor(value: E);
+    protected _value: E;
+    /**
+     * The function returns the value of a protected variable.
+     * @returns The value of the variable `_value` is being returned.
+     */
+    get value(): E;
+    /**
+     * The above function sets the value of a variable.
+     * @param {E} value - The parameter "value" is of type E, which means it can be any type.
+     */
+    set value(value: E);
+    protected _next: DoublyLinkedListNode<E> | undefined;
+    /**
+     * The "next" function returns the next node in a doubly linked list.
+     * @returns The `next` property is being returned. It can be either a `DoublyLinkedListNode<E>`
+     * object or `undefined`.
+     */
+    get next(): DoublyLinkedListNode<E> | undefined;
+    /**
+     * The "next" property of a DoublyLinkedListNode is set to the provided value.
+     * @param {DoublyLinkedListNode<E> | undefined} value - The `value` parameter is of type
+     * `DoublyLinkedListNode<E> | undefined`. This means that it can accept either a
+     * `DoublyLinkedListNode` object or `undefined` as its value.
+     */
+    set next(value: DoublyLinkedListNode<E> | undefined);
+    protected _prev: DoublyLinkedListNode<E> | undefined;
+    /**
+     * The `prev` function returns the previous node in a doubly linked list.
+     * @returns The `prev` property of the `DoublyLinkedListNode` class is being returned. It can either
+     * be a `DoublyLinkedListNode` object or `undefined`.
+     */
+    get prev(): DoublyLinkedListNode<E> | undefined;
+    /**
+     * The function sets the previous node of a doubly linked list node.
+     * @param {DoublyLinkedListNode<E> | undefined} value - The `value` parameter is of type
+     * `DoublyLinkedListNode<E> | undefined`. This means that it can accept either a
+     * `DoublyLinkedListNode` object or `undefined` as its value.
+     */
+    set prev(value: DoublyLinkedListNode<E> | undefined);
 }
 /**
  * 1. Node Structure: Each node contains three parts: a data field, a pointer (or reference) to the previous node, and a pointer to the next node. This structure allows traversal of the linked list in both directions.
@@ -52,12 +88,12 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     get size(): number;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      * where n is the number of elements in the linked list.
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The `get first` function returns the first node in a doubly linked list, or undefined if the list is empty.
@@ -69,7 +105,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The `get last` function returns the last node in a doubly linked list, or undefined if the list is empty.
@@ -77,11 +113,11 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     get last(): E | undefined;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the size of the input array.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
      * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
@@ -116,7 +152,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     pop(): E | undefined;
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
@@ -129,7 +165,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     shift(): E | undefined;
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
@@ -205,12 +241,12 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     addAt(index: number, value: E): boolean;
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      * where n is the number of elements in the linked list.
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      *
      * The `addBefore` function inserts a new value before an existing value or node in a doubly linked list.
@@ -224,11 +260,11 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     addBefore(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      *
      * The `addAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
@@ -252,7 +288,11 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     deleteAt(index: number): boolean;
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1) or O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      *
      * The `delete` function removes a node from a doubly linked list based on either the node itself or its value.
@@ -267,6 +307,9 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * Space Complexity: O(1)
      */
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if a variable has a size greater than zero and returns a boolean value.
      * @returns A boolean value is being returned.
      */
@@ -276,6 +319,9 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * Space Complexity: O(1)
      */
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `clear` function resets the linked list by setting the head, tail, and size to undefined and 0 respectively.
      */
     clear(): void;
@@ -296,7 +342,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
     indexOf(value: E): number;
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -312,7 +358,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
     findBackward(callback: (value: E) => boolean): E | undefined;
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -360,8 +406,8 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     clone(): DoublyLinkedList<E>;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
     /**
      * Time Complexity: O(n)
@@ -382,8 +428,8 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     filter(callback: ElementCallback<E, boolean>, thisArg?: any): DoublyLinkedList<E>;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
     /**
      * Time Complexity: O(n)
@@ -429,7 +475,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     pollLast(): E | undefined;
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
@@ -442,7 +488,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     pollFirst(): E | undefined;
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -9,9 +9,57 @@ class DoublyLinkedListNode {
      * is defined as a generic type "E".
      */
     constructor(value) {
-        this.value = value;
-        this.next = undefined;
-        this.prev = undefined;
+        this._value = value;
+        this._next = undefined;
+        this._prev = undefined;
+    }
+    /**
+     * The function returns the value of a protected variable.
+     * @returns The value of the variable `_value` is being returned.
+     */
+    get value() {
+        return this._value;
+    }
+    /**
+     * The above function sets the value of a variable.
+     * @param {E} value - The parameter "value" is of type E, which means it can be any type.
+     */
+    set value(value) {
+        this._value = value;
+    }
+    /**
+     * The "next" function returns the next node in a doubly linked list.
+     * @returns The `next` property is being returned. It can be either a `DoublyLinkedListNode<E>`
+     * object or `undefined`.
+     */
+    get next() {
+        return this._next;
+    }
+    /**
+     * The "next" property of a DoublyLinkedListNode is set to the provided value.
+     * @param {DoublyLinkedListNode<E> | undefined} value - The `value` parameter is of type
+     * `DoublyLinkedListNode<E> | undefined`. This means that it can accept either a
+     * `DoublyLinkedListNode` object or `undefined` as its value.
+     */
+    set next(value) {
+        this._next = value;
+    }
+    /**
+     * The `prev` function returns the previous node in a doubly linked list.
+     * @returns The `prev` property of the `DoublyLinkedListNode` class is being returned. It can either
+     * be a `DoublyLinkedListNode` object or `undefined`.
+     */
+    get prev() {
+        return this._prev;
+    }
+    /**
+     * The function sets the previous node of a doubly linked list node.
+     * @param {DoublyLinkedListNode<E> | undefined} value - The `value` parameter is of type
+     * `DoublyLinkedListNode<E> | undefined`. This means that it can accept either a
+     * `DoublyLinkedListNode` object or `undefined` as its value.
+     */
+    set prev(value) {
+        this._prev = value;
     }
 }
 exports.DoublyLinkedListNode = DoublyLinkedListNode;
@@ -62,12 +110,12 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return this._size;
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      * where n is the number of elements in the linked list.
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The `get first` function returns the first node in a doubly linked list, or undefined if the list is empty.
@@ -82,7 +130,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The `get last` function returns the last node in a doubly linked list, or undefined if the list is empty.
@@ -93,11 +141,11 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return (_a = this.tail) === null || _a === void 0 ? void 0 : _a.value;
     }
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the size of the input array.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
      * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
@@ -161,7 +209,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return removedNode.value;
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
@@ -188,7 +236,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return removedNode.value;
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
@@ -322,12 +370,12 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return true;
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      * where n is the number of elements in the linked list.
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      *
      * The `addBefore` function inserts a new value before an existing value or node in a doubly linked list.
@@ -364,11 +412,11 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return false;
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      *
      * The `addAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
@@ -433,7 +481,11 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return true;
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1) or O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
      *
      * The `delete` function removes a node from a doubly linked list based on either the node itself or its value.
@@ -473,6 +525,9 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * Space Complexity: O(1)
      */
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if a variable has a size greater than zero and returns a boolean value.
      * @returns A boolean value is being returned.
      */
@@ -484,6 +539,9 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * Space Complexity: O(1)
      */
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `clear` function resets the linked list by setting the head, tail, and size to undefined and 0 respectively.
      */
     clear() {
@@ -519,7 +577,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -544,7 +602,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -619,8 +677,8 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return new DoublyLinkedList(this.values());
     }
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
     /**
      * Time Complexity: O(n)
@@ -651,8 +709,8 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return filteredList;
     }
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
     /**
      * Time Complexity: O(n)
@@ -710,7 +768,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return this.pop();
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
@@ -725,7 +783,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return this.shift();
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**

package/dist/data-structures/linked-list/singly-linked-list.d.ts

@@ -8,14 +8,37 @@
 import type { ElementCallback } from '../../types';
 import { IterableElementBase } from '../base';
 export declare class SinglyLinkedListNode<E = any> {
-    value: E;
-    next: SinglyLinkedListNode<E> | undefined;
     /**
      * The constructor function initializes an instance of a class with a given value and sets the next property to undefined.
      * @param {E} value - The "value" parameter is of type E, which means it can be any data type. It represents the value that
      * will be stored in the node of a linked list.
      */
     constructor(value: E);
+    protected _value: E;
+    /**
+     * The function returns the value of a protected variable.
+     * @returns The value of the variable `_value` is being returned.
+     */
+    get value(): E;
+    /**
+     * The above function sets the value of a variable.
+     * @param {E} value - The parameter "value" is of type E, which means it can be any type.
+     */
+    set value(value: E);
+    protected _next: SinglyLinkedListNode<E> | undefined;
+    /**
+     * The `next` function returns the next node in a singly linked list.
+     * @returns The `next` property is being returned. It can be either a `SinglyLinkedListNode<E>`
+     * object or `undefined`.
+     */
+    get next(): SinglyLinkedListNode<E> | undefined;
+    /**
+     * The "next" property of a SinglyLinkedListNode is set to the provided value.
+     * @param {SinglyLinkedListNode<E> | undefined} value - The `value` parameter is of type
+     * `SinglyLinkedListNode<E> | undefined`. This means that it can accept either a
+     * `SinglyLinkedListNode` object or `undefined` as its value.
+     */
+    set next(value: SinglyLinkedListNode<E> | undefined);
 }
 export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
     /**
@@ -391,7 +414,7 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     filter(callback: ElementCallback<E, boolean>, thisArg?: any): SinglyLinkedList<E>;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**