data-structure-typed 1.50.2 → 1.50.4

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

@@ -86,6 +86,10 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @returns The top element or undefined if the heap is empty.
      */
     poll(): E | undefined;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -104,11 +108,11 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     clear(): void;
     /**
-     * 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
@@ -116,11 +120,11 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     refill(elements: E[]): boolean[];
     /**
-     * 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.
@@ -129,11 +133,12 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     has(element: E): boolean;
     /**
-     * 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
@@ -145,12 +150,13 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     delete(element: E): boolean;
     /**
-     * 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).
@@ -194,12 +200,12 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     sort(): E[];
     /**
-     * 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.
      */
@@ -255,7 +261,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     protected _getIterator(): IterableIterator<E>;
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
@@ -266,6 +272,10 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @param index - The index of the newly added element.
      */
     protected _bubbleUp(index: number): boolean;
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -397,11 +407,11 @@ export declare class FibonacciHeap<E> {
      */
     mergeWithChild(parent: FibonacciHeapNode<E>, node: FibonacciHeapNode<E>): void;
     /**
-     * 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.
@@ -409,11 +419,11 @@ export declare class FibonacciHeap<E> {
      */
     poll(): E | undefined;
     /**
-     * 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/mjs/data-structures/heap/heap.js

@@ -39,7 +39,6 @@ export class Heap extends IterableElementBase {
             for (const el of elements) {
                 this.add(el);
             }
-            // this.fix();
         }
     }
     _comparator = (a, b) => {
@@ -126,6 +125,10 @@ export class Heap extends IterableElementBase {
         }
         return value;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -150,11 +153,11 @@ export class Heap extends 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
@@ -165,11 +168,11 @@ export class Heap extends 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.
@@ -180,11 +183,12 @@ export class Heap extends 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
@@ -212,12 +216,13 @@ export class Heap extends 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).
@@ -301,12 +306,12 @@ export class Heap extends 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.
      */
@@ -389,7 +394,7 @@ export class Heap extends IterableElementBase {
         }
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
@@ -412,6 +417,10 @@ export class Heap extends 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)
@@ -623,11 +632,11 @@ export 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.
@@ -637,11 +646,11 @@ export 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/mjs/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)
      */
     /**