min-heap-typed 1.50.1 → 1.50.3

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

@@ -32,12 +32,20 @@ export class Queue<E = any> extends IterableElementBase<E> {
 
   protected _elements: E[] = [];
 
+  /**
+   * The elements function returns the elements of this set.
+   * @return An array of the elements in the stack
+   */
   get elements(): E[] {
     return this._elements;
   }
 
   protected _offset: number = 0;
 
+  /**
+   * The offset function returns the offset of the current page.
+   * @return The value of the protected variable _offset
+   */
   get offset(): number {
     return this._offset;
   }
@@ -51,8 +59,13 @@ export class Queue<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The `first` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
    * @returns The `get first()` method returns the first element of the data structure, represented by the `_elements` array at
@@ -63,13 +76,13 @@ export class Queue<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The `last` function returns the last element in an array-like data structure, or undefined if the structure is empty.
    * @returns The method `get last()` returns the last element of the `_elements` array if the array is not empty. If the
@@ -80,11 +93,14 @@ export class Queue<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
    */
 
   /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
    * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
    * @public
    * @static
@@ -97,13 +113,13 @@ export class Queue<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The push function adds an element to the end of the queue and returns the updated queue.Adds an element at the back of the queue.
    * @param {E} element - The `element` parameter represents the element that you want to add to the queue.
@@ -115,13 +131,13 @@ export class Queue<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The `shift` function removes and returns the first element in the queue, and adjusts the internal data structure if
    * necessary to optimize performance.
@@ -143,13 +159,33 @@ export class Queue<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-   * Space Complexity: O(1) - no additional space is used.
+   * The delete function removes an element from the list.
+   * @param element: E Specify the element to be deleted
+   * @return A boolean value indicating whether the element was successfully deleted or not
+   */
+  delete(element: E): boolean {
+    const index = this.elements.indexOf(element);
+    return this.deleteAt(index);
+  }
+
+  /**
+   * The deleteAt function deletes the element at a given index.
+   * @param index: number Determine the index of the element to be deleted
+   * @return A boolean value
+   */
+  deleteAt(index: number): boolean {
+    const spliced = this.elements.splice(index, 1);
+    return spliced.length === 1;
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The `peek` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
    * @returns The `peek()` method returns the first element of the data structure, represented by the `_elements` array at
@@ -160,13 +196,13 @@ export class Queue<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The `peekLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
    * @returns The method `peekLast()` returns the last element of the `_elements` array if the array is not empty. If the
@@ -177,13 +213,13 @@ export class Queue<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The enqueue function adds a value to the end of a queue.
    * @param {E} value - The value parameter represents the value that you want to add to the queue.
@@ -193,13 +229,13 @@ export class Queue<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n) - same as shift().
-   * Space Complexity: O(1) - same as shift().
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(n) - same as shift().
-   * Space Complexity: O(1) - same as shift().
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
    * @returns The method is returning a value of type E or undefined.
@@ -209,28 +245,28 @@ export class Queue<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * @param index
    */
-  getAt(index: number): E | undefined {
+  at(index: number): E | undefined {
     return this.elements[index];
   }
 
   /**
-   * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
-   * Space Complexity: O(1) - no additional space is used.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The function checks if a data structure is empty by comparing its size to zero.
    * @returns {boolean} A boolean value indicating whether the size of the object is 0 or not.
@@ -240,13 +276,13 @@ export class Queue<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1) - constant time as it returns a shallow copy of the internal array.
-   * Space Complexity: O(n) - where n is the number of elements in the queue.
+   * Time Complexity: O(1)
+   * Space Complexity: O(n)
    */
 
   /**
-   * Time Complexity: O(1) - constant time as it returns a shallow copy of the internal array.
-   * Space Complexity: O(n) - where n is the number of elements in the queue.
+   * Time Complexity: O(1)
+   * Space Complexity: O(n)
    *
    * The toArray() function returns an array of elements from the current offset to the end of the _elements array.
    * @returns An array of type E is being returned.
@@ -256,6 +292,14 @@ export class Queue<E = any> extends IterableElementBase<E> {
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The clear function resets the elements array and offset to their initial values.
    */
   clear(): void {
@@ -264,13 +308,14 @@ export class Queue<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n) - where n is the number of elements in the queue. It creates a shallow copy of the internal array.
-   * Space Complexity: O(n) - the space required is proportional to the number of elements in the queue.
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   * where n is the number of elements in the queue. It creates a shallow copy of the internal array. the space required is proportional to the number of elements in the queue.
    */
 
   /**
-   * Time Complexity: O(n) - where n is the number of elements in the queue. It creates a shallow copy of the internal array.
-   * Space Complexity: O(n) - the space required is proportional to the number of elements in the queue.
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
    *
    * The `clone()` function returns a new Queue object with the same elements as the original Queue.
    * @returns The `clone()` method is returning a new instance of the `Queue` class.
@@ -316,6 +361,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * Time Complexity: O(n)
    * Space Complexity: O(n)
    */
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -345,6 +391,12 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * Space Complexity: O(n)
    */
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The function `_getIterator` returns an iterable iterator for the elements in the class.
+   */
   protected* _getIterator(): IterableIterator<E> {
     for (const item of this.elements) {
       yield item;
@@ -390,4 +442,21 @@ export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
   peek(): E | undefined {
     return this.first;
   }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   * The `clone` function returns a new instance of the `LinkedListQueue` class with the same values as
+   * the current instance.
+   * @returns The `clone()` method is returning a new instance of `LinkedListQueue` with the same
+   * values as the original `LinkedListQueue`.
+   */
+  clone(): LinkedListQueue<E> {
+    return new LinkedListQueue<E>(this.values());
+  }
 }

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

@@ -32,15 +32,14 @@ export class Stack<E = any> extends IterableElementBase<E> {
 
   protected _elements: E[] = [];
 
+  /**
+   * The elements function returns the elements of this set.
+   * @return An array of elements
+   */
   get elements(): E[] {
     return this._elements;
   }
 
-  /**
-   * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
-   * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
-   */
-
   /**
    * The size() function returns the number of elements in an array.
    * @returns The size of the elements array.
@@ -50,8 +49,13 @@ export class Stack<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
-   * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
    *
    * The function "fromArray" creates a new Stack object from an array of elements.
    * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
@@ -71,13 +75,13 @@ export class Stack<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1), as it only involves accessing the last element of the array.
-   * Space Complexity: O(1), as it does not use any additional space.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(1), as it only involves accessing the last element of the array.
-   * Space Complexity: O(1), as it does not use any additional space.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The `peek` function returns the last element of an array, or undefined if the array is empty.
    * @returns The `peek()` function returns the last element of the `_elements` array, or `undefined` if the array is empty.
@@ -89,13 +93,13 @@ export class Stack<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1), as it only involves accessing the last element of the array.
-   * Space Complexity: O(1), as it does not use any additional space.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(1), as it only involves accessing the last element of the array.
-   * Space Complexity: O(1), as it does not use any additional space.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The push function adds an element to the stack and returns the updated stack.
    * @param {E} element - The parameter "element" is of type E, which means it can be any data type.
@@ -107,13 +111,13 @@ export class Stack<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1), as it only involves accessing the last element of the array.
-   * Space Complexity: O(1), as it does not use any additional space.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(1), as it only involves accessing the last element of the array.
-   * Space Complexity: O(1), as it does not use any additional space.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * The `pop` function removes and returns the last element from an array, or returns undefined if the array is empty.
    * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
@@ -125,6 +129,26 @@ export class Stack<E = any> extends IterableElementBase<E> {
     return this.elements.pop();
   }
 
+  /**
+   * The delete function removes an element from the stack.
+   * @param element: E Specify the element to be deleted
+   * @return A boolean value indicating whether the element was successfully deleted or not
+   */
+  delete(element: E): boolean {
+    const index = this.elements.indexOf(element);
+    return this.deleteAt(index);
+  }
+
+  /**
+   * The deleteAt function deletes the element at a given index.
+   * @param index: number Determine the index of the element to be deleted
+   * @return A boolean value
+   */
+  deleteAt(index: number): boolean {
+    const spliced = this.elements.splice(index, 1);
+    return spliced.length === 1;
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -142,6 +166,14 @@ export class Stack<E = any> extends IterableElementBase<E> {
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The clear function clears the elements array.
    */
   clear(): void {
@@ -149,13 +181,13 @@ export class Stack<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the stack, as it creates a new stack and copies all elements into it.
-   * Space Complexity: O(n), as it creates a new stack.
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the stack, as it creates a new stack and copies all elements into it.
-   * Space Complexity: O(n), as it creates a new stack.
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
    *
    * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
    * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
@@ -226,6 +258,14 @@ export class Stack<E = any> extends IterableElementBase<E> {
   }
 
   /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
    * Custom iterator for the Stack class.
    * @returns An iterator object.
    */

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

@@ -1,25 +1,99 @@
 export class TreeNode<V = any> {
-  key: string;
-  value?: V | undefined;
-  children?: TreeNode<V>[] | undefined;
-
+  /**
+   * The constructor function initializes a TreeNode object with a key, optional value, and optional
+   * children.
+   * @param {string} key - A string representing the key of the tree node.
+   * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
+   * value associated with the node. If no value is provided, it defaults to `undefined`.
+   * @param {TreeNode<V>[]} [children] - The `children` parameter is an optional array of `TreeNode<V>`
+   * objects. It represents the child nodes of the current node. If no children are provided, the
+   * default value is an empty array.
+   */
   constructor(key: string, value?: V, children?: TreeNode<V>[]) {
-    this.key = key;
-    this.value = value || undefined;
-    this.children = children || [];
+    this._key = key;
+    this._value = value || undefined;
+    this._children = children || [];
+  }
+
+  protected _key: string;
+
+  /**
+   * The function returns the value of the protected variable _key.
+   * @returns The value of the `_key` property, which is a string.
+   */
+  get key(): string {
+    return this._key;
+  }
+
+  /**
+   * The above function sets the value of a protected variable called "key".
+   * @param {string} value - The value parameter is a string that represents the value to be assigned
+   * to the key.
+   */
+  set key(value: string) {
+    this._key = value;
+  }
+
+  protected _value?: V | undefined;
+
+  /**
+   * The function returns the value stored in a variable, or undefined if the variable is empty.
+   * @returns The value of the variable `_value` is being returned.
+   */
+  get value(): V | undefined {
+    return this._value;
+  }
+
+  /**
+   * The function sets the value of a variable.
+   * @param {V | undefined} value - The parameter "value" is of type "V | undefined", which means it
+   * can accept a value of type "V" or it can be undefined.
+   */
+  set value(value: V | undefined) {
+    this._value = value;
+  }
+
+  protected _children?: TreeNode<V>[] | undefined;
+
+  /**
+   * The function returns an array of TreeNode objects or undefined.
+   * @returns The `children` property is being returned. It is of type `TreeNode<V>[] | undefined`,
+   * which means it can either be an array of `TreeNode<V>` objects or `undefined`.
+   */
+  get children(): TreeNode<V>[] | undefined {
+    return this._children;
+  }
+
+  /**
+   * The function sets the value of the children property of a TreeNode object.
+   * @param {TreeNode<V>[] | undefined} value - The value parameter is of type TreeNode<V>[] |
+   * undefined. This means that it can accept an array of TreeNode objects or undefined.
+   */
+  set children(value: TreeNode<V>[] | undefined) {
+    this._children = value;
   }
 
+  /**
+   * The function `addChildren` adds one or more child nodes to the current node.
+   * @param {TreeNode<V> | TreeNode<V>[]} children - The `children` parameter can be either a single
+   * `TreeNode<V>` object or an array of `TreeNode<V>` objects.
+   */
   addChildren(children: TreeNode<V> | TreeNode<V>[]) {
-    if (!this.children) {
-      this.children = [];
+    if (!this._children) {
+      this._children = [];
     }
     if (children instanceof TreeNode) {
-      this.children.push(children);
+      this._children.push(children);
     } else {
-      this.children = this.children.concat(children);
+      this._children = this._children.concat(children);
     }
   }
 
+  /**
+   * The function `getHeight()` calculates the maximum depth of a tree structure by performing a
+   * breadth-first search.
+   * @returns the maximum depth or height of the tree.
+   */
   getHeight() {
     let maxDepth = 0;
     if (this) {
@@ -27,10 +101,10 @@ export class TreeNode<V = any> {
         if (level > maxDepth) {
           maxDepth = level;
         }
-        const { children } = node;
-        if (children) {
-          for (let i = 0, len = children.length; i < len; i++) {
-            bfs(children[i], level + 1);
+        const { _children } = node;
+        if (_children) {
+          for (let i = 0, len = _children.length; i < len; i++) {
+            bfs(_children[i], level + 1);
           }
         }
       };