min-heap-typed 1.50.1 → 1.50.3

package/dist/data-structures/queue/deque.d.ts

@@ -15,16 +15,68 @@ import { IterableElementBase } from '../base';
  * 5. Performance jitter: Deque may experience performance jitter, but DoublyLinkedList will not
  */
 export declare class Deque<E> extends IterableElementBase<E> {
+    /**
+     * The constructor initializes a Deque object with an optional iterable of elements and options.
+     * @param elements - An iterable object (such as an array or a Set) that contains the initial
+     * elements to be added to the deque. It can also be an object with a `length` or `size` property
+     * that represents the number of elements in the iterable object. If no elements are provided, an
+     * empty deque
+     * @param {DequeOptions} [options] - The `options` parameter is an optional object that can contain
+     * configuration options for the deque. In this code, it is used to set the `bucketSize` option,
+     * which determines the size of each bucket in the deque. If the `bucketSize` option is not provided
+     * or is not a number
+     */
+    constructor(elements?: IterableWithSizeOrLength<E>, options?: DequeOptions);
+    protected _bucketSize: number;
+    /**
+     * The bucketSize function returns the size of the bucket.
+     *
+     * @return The size of the bucket
+     */
+    get bucketSize(): number;
     protected _bucketFirst: number;
+    /**
+     * The function returns the value of the protected variable `_bucketFirst`.
+     * @returns The value of the `_bucketFirst` property.
+     */
+    get bucketFirst(): number;
     protected _firstInBucket: number;
+    /**
+     * The function returns the value of the protected variable _firstInBucket.
+     * @returns The method is returning the value of the variable `_firstInBucket`, which is of type
+     * `number`.
+     */
+    get firstInBucket(): number;
     protected _bucketLast: number;
+    /**
+     * The function returns the value of the protected variable `_bucketLast`.
+     * @returns The value of the `_bucketLast` property, which is a number.
+     */
+    get bucketLast(): number;
     protected _lastInBucket: number;
+    /**
+     * The function returns the value of the protected variable _lastInBucket.
+     * @returns The method is returning the value of the variable `_lastInBucket`, which is of type
+     * `number`.
+     */
+    get lastInBucket(): number;
     protected _bucketCount: number;
-    protected readonly _bucketSize: number;
-    constructor(elements?: IterableWithSizeOrLength<E>, options?: DequeOptions);
+    /**
+     * The function returns the number of buckets.
+     * @returns The number of buckets.
+     */
+    get bucketCount(): number;
     protected _buckets: E[][];
+    /**
+     * The buckets function returns the buckets property of the object.
+     * @return The buckets property
+     */
     get buckets(): E[][];
     protected _size: number;
+    /**
+     * The size function returns the number of items in the stack.
+     * @return The number of values in the set
+     */
     get size(): number;
     /**
      * The function returns the first element in a collection if it exists, otherwise it returns
@@ -32,6 +84,10 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * @returns The first element of the collection, of type E, is being returned.
      */
     get first(): E | undefined;
+    /**
+     * The last function returns the last element in the queue.
+     * @return The last element in the array
+     */
     get last(): E | undefined;
     /**
      * Time Complexity - Amortized O(1) (possible reallocation)
@@ -90,11 +146,25 @@ export declare class Deque<E> extends IterableElementBase<E> {
      */
     shift(): E | undefined;
     /**
-     * Time Complexity: O(1) - Removes the last element.
-     * Space Complexity: O(1) - Operates in-place.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function checks if the size of an object is equal to zero and returns a boolean value.
+     * @returns A boolean value indicating whether the size of the object is 0 or not.
      */
     isEmpty(): boolean;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear() function resets the state of the object by initializing all variables to their default
      * values.
      */
@@ -116,13 +186,13 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `getAt` function retrieves an element at a specified position in an array-like data structure.
+     * The `at` function retrieves an element at a specified position in an array-like data structure.
      * @param {number} pos - The `pos` parameter represents the position of the element that you want to
      * retrieve from the data structure. It is of type `number` and should be a valid index within the
      * range of the data structure.
      * @returns The element at the specified position in the data structure is being returned.
      */
-    getAt(pos: number): E;
+    at(pos: number): E;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -170,16 +240,37 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * updated size.
      * @param {number} pos - The `pos` parameter represents the position at which the string should be
      * cut. It is a number that indicates the index of the character where the cut should be made.
+     * @param {boolean} isCutSelf - If true, the original deque will not be cut, and return a new deque
      * @returns The method is returning the updated size of the data structure.
      */
-    cut(pos: number): number;
+    cut(pos: number, isCutSelf?: boolean): Deque<E>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1) or O(n)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1) or O(n)
+     *
+     * The `cutRest` function cuts the elements from a specified position in a deque and returns a new
+     * deque with the cut elements.
+     * @param {number} pos - The `pos` parameter represents the position from which to cut the Deque. It
+     * is a number that indicates the index of the element in the Deque where the cut should start.
+     * @param [isCutSelf=false] - isCutSelf is a boolean parameter that determines whether the original
+     * Deque should be modified or a new Deque should be created. If isCutSelf is true, the original
+     * Deque will be modified by cutting off elements starting from the specified position. If isCutSelf
+     * is false, a new De
+     * @returns The function `cutRest` returns either the modified original deque (`this`) or a new deque
+     * (`newDeque`) depending on the value of the `isCutSelf` parameter.
+     */
+    cutRest(pos: number, isCutSelf?: boolean): Deque<E>;
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(1) or O(n)
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(1) or O(n)
      *
      * The `deleteAt` function removes an element at a specified position in an array-like data
      * structure.
@@ -260,22 +351,6 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * `this.size` is 0, but it does not return any value.
      */
     shrinkToFit(): void;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `find` function iterates over the elements in a deque and returns the first element for which
-     * the callback function returns true, or undefined if no such element is found.
-     * @param callback - A function that takes three parameters: element, index, and deque. It should
-     * return a boolean value indicating whether the element satisfies a certain condition.
-     * @returns The method `find` returns the first element in the deque that satisfies the condition
-     * specified by the callback function. If no element satisfies the condition, it returns `undefined`.
-     */
-    find(callback: (element: E, index: number, deque: Deque<E>) => boolean): E | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -304,6 +379,20 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * @returns The `toArray()` method is returning an array of elements of type `E`.
      */
     toArray(): E[];
+    /**
+     * 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 `Deque` class with the same elements and
+     * bucket size as the original instance.
+     * @returns The `clone()` method is returning a new instance of the `Deque` class with the same
+     * elements as the original deque (`this`) and the same bucket size.
+     */
+    clone(): Deque<E>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -348,8 +437,8 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * Space Complexity: O(n) - Due to potential resizing.
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(n) - In worst case, resizing doubles the array size.
+     * Time Complexity: Amortized O(1) - Similar to push, resizing leads to O(n).
+     * Space Complexity: O(n) - Due to potential resizing.
      *
      * The addLast function adds an element to the end of an array.
      * @param {E} element - The element parameter represents the element that you want to add to the end of the
@@ -357,20 +446,25 @@ export declare class Deque<E> extends IterableElementBase<E> {
      */
     addLast(element: E): boolean;
     /**
-     * Time Complexity: O(1) - Removes the first element.
-     * Space Complexity: O(1) - In-place operation.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - Removes the last element.
-     * Space Complexity: O(1) - Operates in-place.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function "pollLast" removes and returns the last element of an array.
      * @returns The last element of the array is being returned.
      */
     pollLast(): E | undefined;
     /**
-     * Time Complexity: O(1).
-     * Space Complexity: O(n) - Due to potential resizing.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The "addFirst" function adds an element to the beginning of an array.
      * @param {E} element - The parameter "element" represents the element that you want to add to the
@@ -378,8 +472,13 @@ export declare class Deque<E> extends IterableElementBase<E> {
      */
     addFirst(element: E): boolean;
     /**
-     * Time Complexity: O(1) - Removes the first element.
-     * Space Complexity: O(1) - In-place operation.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function "pollFirst" removes and returns the first element of an array.
      * @returns The method `pollFirst()` is returning the first element of the array after removing it
@@ -387,6 +486,11 @@ export declare class Deque<E> extends IterableElementBase<E> {
      */
     pollFirst(): E | undefined;
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *