min-heap-typed 1.50.2 → 1.50.4

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

@@ -43,7 +43,6 @@ export class Heap<E = any> extends IterableElementBase<E> {
       for (const el of elements) {
         this.add(el);
       }
-      // this.fix();
     }
   }
 
@@ -140,6 +139,11 @@ export class Heap<E = any> extends IterableElementBase<E> {
     return value;
   }
 
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   */
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -167,12 +171,12 @@ export class Heap<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * 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
@@ -184,12 +188,12 @@ export class Heap<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * 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.
@@ -201,12 +205,13 @@ export class Heap<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * 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
@@ -232,13 +237,14 @@ export class Heap<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * 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).
@@ -330,13 +336,13 @@ export class Heap<E = any> extends IterableElementBase<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.
    */
@@ -424,7 +430,7 @@ export class Heap<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n)
+   * Time Complexity: O(log n)
    * Space Complexity: O(1)
    */
 
@@ -448,6 +454,11 @@ export class Heap<E = any> extends IterableElementBase<E> {
     return true;
   }
 
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   */
+
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -683,12 +694,12 @@ export class FibonacciHeap<E> {
   }
 
   /**
-   * 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.
@@ -699,12 +710,12 @@ export class FibonacciHeap<E> {
   }
 
   /**
-   * 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/src/data-structures/linked-list/doubly-linked-list.ts

@@ -9,19 +9,75 @@ import type { ElementCallback } from '../../types';
 import { IterableElementBase } from '../base';
 
 export 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) {
-    this.value = value;
-    this.next = undefined;
-    this.prev = undefined;
+    this._value = value;
+    this._next = undefined;
+    this._prev = undefined;
+  }
+
+  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 {
+    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: E) {
+    this._value = value;
+  }
+
+  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 {
+    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: DoublyLinkedListNode<E> | undefined) {
+    this._next = value;
+  }
+
+  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 {
+    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: DoublyLinkedListNode<E> | undefined) {
+    this._prev = value;
   }
 }
 
@@ -82,13 +138,13 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * 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.
@@ -104,7 +160,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    */
 
   /**
-   * 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.
@@ -115,12 +171,12 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * 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
@@ -186,7 +242,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n)
+   * Time Complexity: O(1)
    * Space Complexity: O(1)
    */
 
@@ -213,7 +269,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n)
+   * Time Complexity: O(1)
    * Space Complexity: O(1)
    */
 
@@ -356,13 +412,13 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * 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.
@@ -402,12 +458,12 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * 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.
@@ -476,7 +532,12 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * 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.
@@ -517,6 +578,9 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    */
 
   /**
+   * 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.
    */
@@ -530,6 +594,9 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    */
 
   /**
+   * 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 {
@@ -568,7 +635,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
 
   /**
    * Time Complexity: O(n)
-   * Space Complexity: O(n)
+   * Space Complexity: O(1)
    */
 
   /**
@@ -595,7 +662,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
 
   /**
    * Time Complexity: O(n)
-   * Space Complexity: O(n)
+   * Space Complexity: O(1)
    */
 
   /**
@@ -678,8 +745,8 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
    */
 
   /**
@@ -712,8 +779,8 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
    */
 
   /**
@@ -778,7 +845,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n)
+   * Time Complexity: O(1)
    * Space Complexity: O(1)
    */
 
@@ -795,7 +862,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n)
+   * Time Complexity: O(1)
    * Space Complexity: O(1)
    */
 

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -9,17 +9,53 @@ import type { ElementCallback } from '../../types';
 import { IterableElementBase } from '../base';
 
 export 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) {
-    this.value = value;
-    this.next = undefined;
+    this._value = value;
+    this._next = undefined;
+  }
+
+  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 {
+    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: E) {
+    this._value = value;
+  }
+
+  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 {
+    return this._next;
+  }
+
+  /**
+   * 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) {
+    this._next = value;
   }
 }
 
@@ -728,7 +764,7 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(n)
    */
   /**

package/src/data-structures/linked-list/skip-linked-list.ts

@@ -53,7 +53,7 @@ export class SkipList<K, V> {
   protected _level: number = 0;
 
   /**
-   * The function returns the value of the private variable _level.
+   * The function returns the value of the protected variable _level.
    * @returns The level property of the object.
    */
   get level(): number {
@@ -74,7 +74,7 @@ export class SkipList<K, V> {
 
   /**
    * The function returns the probability value.
-   * @returns The probability value stored in the private variable `_probability` is being returned.
+   * @returns The probability value stored in the protected variable `_probability` is being returned.
    */
   get probability(): number {
     return this._probability;

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

@@ -53,7 +53,7 @@ export class Matrix {
   protected _cols: number = 0;
 
   /**
-   * The function returns the value of the private variable _cols.
+   * The function returns the value of the protected variable _cols.
    * @returns The number of columns.
    */
   get cols(): number {

package/src/data-structures/priority-queue/max-priority-queue.ts

@@ -9,6 +9,16 @@ import type { PriorityQueueOptions } from '../../types';
 import { PriorityQueue } from './priority-queue';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
+  /**
+   * The constructor initializes a PriorityQueue with optional elements and options, including a
+   * comparator function.
+   * @param elements - The `elements` parameter is an iterable object that contains the initial
+   * elements to be added to the priority queue. It is optional and defaults to an empty array if not
+   * provided.
+   * @param options - The `options` parameter is an object that contains additional configuration
+   * options for the priority queue. In this case, it has a property called `comparator` which is a
+   * function used to compare elements in the priority queue.
+   */
   constructor(
     elements: Iterable<E> = [],
     options: PriorityQueueOptions<E> = {

package/src/data-structures/priority-queue/min-priority-queue.ts

@@ -9,6 +9,17 @@ import type { PriorityQueueOptions } from '../../types';
 import { PriorityQueue } from './priority-queue';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
+  /**
+   * The constructor initializes a PriorityQueue with optional elements and options, including a
+   * comparator function.
+   * @param elements - The `elements` parameter is an iterable object that contains the initial
+   * elements to be added to the priority queue. It is optional and defaults to an empty array if not
+   * provided.
+   * @param options - The `options` parameter is an object that contains additional configuration
+   * options for the priority queue. In this case, it has a property called `comparator` which is a
+   * function used to compare elements in the priority queue. The `comparator` function takes two
+   * parameters `a` and `b`,
+   */
   constructor(
     elements: Iterable<E> = [],
     options: PriorityQueueOptions<E> = {

package/src/data-structures/priority-queue/priority-queue.ts

@@ -17,6 +17,14 @@ import { Heap } from '../heap';
  * 6. Kth Largest Element in a Data Stream: Used to maintain a min-heap of size K for quickly finding the Kth largest element in stream data
  */
 export class PriorityQueue<E = any> extends Heap<E> {
+  /**
+   * The constructor initializes a priority queue with optional elements and options.
+   * @param elements - The `elements` parameter is an iterable object that contains the initial
+   * elements to be added to the priority queue. It is an optional parameter and if not provided, the
+   * priority queue will be initialized as empty.
+   * @param [options] - The `options` parameter is an optional object that can be used to customize the
+   * behavior of the priority queue. It can contain the following properties:
+   */
   constructor(elements: Iterable<E> = [], options?: PriorityQueueOptions<E>) {
     super(elements, options);
   }