min-heap-typed 1.50.1 → 1.50.3

package/dist/data-structures/stack/stack.d.ts

@@ -24,19 +24,23 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      */
     constructor(elements?: Iterable<E>);
     protected _elements: E[];
-    get elements(): 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.
+     * The elements function returns the elements of this set.
+     * @return An array of elements
      */
+    get elements(): E[];
     /**
      * The size() function returns the number of elements in an array.
      * @returns The size of the elements array.
      */
     get size(): number;
     /**
-     * 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`.
@@ -50,24 +54,24 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      */
     isEmpty(): boolean;
     /**
-     * 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.
      */
     peek(): E | undefined;
     /**
-     * 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.
@@ -75,18 +79,30 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      */
     push(element: E): boolean;
     /**
-     * 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
      * array is empty, it returns `undefined`.
      */
     pop(): E | undefined;
+    /**
+     * 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;
+    /**
+     * 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;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -100,16 +116,23 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      */
     toArray(): 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;
     /**
-     * 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.
@@ -155,6 +178,13 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      */
     map<T>(callback: ElementCallback<E, T>, thisArg?: any): Stack<T>;
     /**
+     * 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/dist/data-structures/stack/stack.js

@@ -25,13 +25,13 @@ class Stack extends base_1.IterableElementBase {
                 this.push(el);
         }
     }
+    /**
+     * The elements function returns the elements of this set.
+     * @return An array of elements
+     */
     get elements() {
         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.
@@ -40,8 +40,12 @@ class Stack extends base_1.IterableElementBase {
         return this.elements.length;
     }
     /**
-     * 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`.
@@ -59,12 +63,12 @@ class Stack extends base_1.IterableElementBase {
         return this.elements.length === 0;
     }
     /**
-     * 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.
@@ -75,12 +79,12 @@ class Stack extends base_1.IterableElementBase {
         return this.elements[this.elements.length - 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)
      */
     /**
-     * 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.
@@ -91,12 +95,12 @@ class Stack extends base_1.IterableElementBase {
         return true;
     }
     /**
-     * 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
@@ -107,6 +111,24 @@ class Stack extends base_1.IterableElementBase {
             return;
         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) {
+        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) {
+        const spliced = this.elements.splice(index, 1);
+        return spliced.length === 1;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -122,18 +144,25 @@ class Stack extends base_1.IterableElementBase {
         return this.elements.slice();
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear function clears the elements array.
      */
     clear() {
         this._elements = [];
     }
     /**
-     * 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.
@@ -199,6 +228,13 @@ class Stack extends base_1.IterableElementBase {
         return newStack;
     }
     /**
+     * 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/dist/data-structures/tree/tree.d.ts

@@ -1,8 +1,62 @@
 export declare 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>[]);
+    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;
+    /**
+     * 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);
+    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;
+    /**
+     * 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);
+    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;
+    /**
+     * 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);
+    /**
+     * 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>[]): void;
+    /**
+     * 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(): number;
 }

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

@@ -2,22 +2,88 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeNode = void 0;
 class TreeNode {
+    /**
+     * 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, value, children) {
-        this.key = key;
-        this.value = value || undefined;
-        this.children = children || [];
+        this._key = key;
+        this._value = value || undefined;
+        this._children = children || [];
     }
+    /**
+     * The function returns the value of the protected variable _key.
+     * @returns The value of the `_key` property, which is a string.
+     */
+    get key() {
+        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) {
+        this._key = value;
+    }
+    /**
+     * 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() {
+        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) {
+        this._value = value;
+    }
+    /**
+     * 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() {
+        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) {
+        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) {
-        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) {
@@ -25,10 +91,10 @@ class TreeNode {
                 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);
                     }
                 }
             };