data-structure-typed 1.48.8 → 1.49.0

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

@@ -66,10 +66,6 @@ export class BinaryTreeNode {
  * 3. Depth and Height: Depth is the number of edges from the root to a node; height is the maximum depth in the tree.
  * 4. Subtrees: Each child of a node forms the root of a subtree.
  * 5. Leaf Nodes: Nodes without children are leaves.
- * 6. Internal Nodes: Nodes with at least one child are internal.
- * 7. Balanced Trees: The heights of the left and right subtrees of any node differ by no more than one.
- * 8. Full Trees: Every node has either 0 or 2 children.
- * 9. Complete Trees: All levels are fully filled except possibly the last, filled from left to right.
  */
 export class BinaryTree extends IterableEntryBase {
     iterationType = IterationType.ITERATIVE;
@@ -198,44 +194,50 @@ export class BinaryTree extends IterableEntryBase {
      * @returns The function `add` returns either a node (`N`), `null`, or `undefined`.
      */
     add(keyOrNodeOrEntry, value) {
-        let inserted;
         const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
         if (newNode === undefined)
             return;
-        // TODO There are still some problems with the way duplicate nodes are handled
-        if (newNode !== null && this.has(newNode.key))
-            return undefined;
-        const _bfs = (root, newNode) => {
-            const queue = new Queue([root]);
-            while (queue.size > 0) {
-                const cur = queue.shift();
-                if (newNode && cur.key === newNode.key) {
-                    this._replaceNode(cur, newNode);
-                    return newNode;
-                }
-                const inserted = this._addTo(newNode, cur);
-                if (inserted !== undefined)
-                    return inserted;
-                if (cur.left)
-                    queue.push(cur.left);
-                if (cur.right)
-                    queue.push(cur.right);
+        // If the tree is empty, directly set the new node as the root node
+        if (!this.root) {
+            this._root = newNode;
+            this._size = 1;
+            return newNode;
+        }
+        const queue = new Queue([this.root]);
+        let potentialParent; // Record the parent node of the potential insertion location
+        while (queue.size > 0) {
+            const cur = queue.shift();
+            if (!cur)
+                continue;
+            // Check for duplicate keys when newNode is not null
+            if (newNode !== null && cur.key === newNode.key) {
+                this._replaceNode(cur, newNode);
+                return newNode; // If duplicate keys are found, no insertion is performed
+            }
+            // Record the first possible insertion location found
+            if (potentialParent === undefined && (cur.left === undefined || cur.right === undefined)) {
+                potentialParent = cur;
+            }
+            // Continue traversing the left and right subtrees
+            if (cur.left !== null) {
+                cur.left && queue.push(cur.left);
+            }
+            if (cur.right !== null) {
+                cur.right && queue.push(cur.right);
             }
-        };
-        if (this.root) {
-            inserted = _bfs(this.root, newNode);
         }
-        else {
-            this._setRoot(newNode);
-            if (newNode) {
-                this._size = 1;
+        // At the end of the traversal, if the insertion position is found, insert
+        if (potentialParent) {
+            if (potentialParent.left === undefined) {
+                potentialParent.left = newNode;
             }
-            else {
-                this._size = 0;
+            else if (potentialParent.right === undefined) {
+                potentialParent.right = newNode;
             }
-            inserted = this.root;
+            this._size++;
+            return newNode;
         }
-        return inserted;
+        return undefined; // If the insertion position cannot be found, return undefined
     }
     /**
      * Time Complexity: O(k log n) - O(k * n)
@@ -977,7 +979,7 @@ export class BinaryTree extends IterableEntryBase {
      * @returns a boolean value.
      */
     isRealNode(node) {
-        return node instanceof BinaryTreeNode && node.key.toString() !== 'NaN';
+        return node instanceof BinaryTreeNode && String(node.key) !== 'NaN';
     }
     /**
      * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
@@ -985,7 +987,7 @@ export class BinaryTree extends IterableEntryBase {
      * @returns a boolean value.
      */
     isNIL(node) {
-        return node instanceof BinaryTreeNode && node.key.toString() === 'NaN';
+        return node instanceof BinaryTreeNode && String(node.key) === 'NaN';
     }
     /**
      * The function checks if a given node is a real node or null.
@@ -996,7 +998,7 @@ export class BinaryTree extends IterableEntryBase {
         return this.isRealNode(node) || node === null;
     }
     /**
-     * The function "isNotNodeInstance" checks if a potential key is a number.
+     * The function "isNotNodeInstance" checks if a potential key is a K.
      * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
      * data type.
      * @returns a boolean value indicating whether the potentialKey is of type number or not.
@@ -1277,19 +1279,23 @@ export class BinaryTree extends IterableEntryBase {
         return levelsNodes;
     }
     /**
-     * The function `getPredecessor` returns the predecessor node of a given node in a binary tree.
-     * @param {K | N | null | undefined} node - The `node` parameter can be of type `K`, `N`,
-     * `null`, or `undefined`.
-     * @returns The function `getPredecessor` returns a value of type `N | undefined`.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The function returns the predecessor of a given node in a tree.
+     * @param {N} node - The parameter `node` is of type `RedBlackTreeNode`, which represents a node in a
+     * tree.
+     * @returns the predecessor of the given 'node'.
      */
     getPredecessor(node) {
-        node = this.ensureNode(node);
-        if (!this.isRealNode(node))
-            return undefined;
-        if (node.left) {
+        if (this.isRealNode(node.left)) {
             let predecessor = node.left;
             while (!this.isRealNode(predecessor) || (this.isRealNode(predecessor.right) && predecessor.right !== node)) {
-                if (predecessor) {
+                if (this.isRealNode(predecessor)) {
                     predecessor = predecessor.right;
                 }
             }
@@ -1307,13 +1313,13 @@ export class BinaryTree extends IterableEntryBase {
      */
     getSuccessor(x) {
         x = this.ensureNode(x);
-        if (!x)
+        if (!this.isRealNode(x))
             return undefined;
-        if (x.right) {
+        if (this.isRealNode(x.right)) {
             return this.getLeftMost(x.right);
         }
         let y = x.parent;
-        while (y && y && x === y.right) {
+        while (this.isRealNode(y) && x === y.right) {
             x = y;
             y = y.parent;
         }

package/dist/mjs/data-structures/binary-tree/bst.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BSTNested, BSTNodeKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNodeExemplar } from '../../types';
-import { BSTVariant, CP, IterationType } from '../../types';
+import { BSTVariant, BTNodeKeyOrNode, CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 export declare class BSTNode<K = any, V = any, N extends BSTNode<K, V, N> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, N> {
@@ -169,6 +169,13 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key: K, iterationType?: IterationType): N | undefined;
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.

package/dist/mjs/data-structures/binary-tree/bst.js

@@ -390,6 +390,15 @@ export class BST extends BinaryTree {
             }
         }
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof BSTNode);
+    }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.

package/dist/mjs/data-structures/binary-tree/rb-tree.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BiTreeDeleteResult, BTNCallback, BTNodeExemplar, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import { BiTreeDeleteResult, BTNCallback, BTNodeExemplar, BTNodeKeyOrNode, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any, N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, N> {
@@ -65,6 +65,13 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * class.
      */
     isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
     /**
      * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
      * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
@@ -120,24 +127,11 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
     getNode<C extends BTNCallback<N, N>>(identifier: N | undefined, callback?: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
     getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     *
-     * The function returns the successor of a given node in a red-black tree.
-     * @param {RedBlackTreeNode} x - RedBlackTreeNode - The node for which we want to find the successor.
-     * @returns the successor of the given RedBlackTreeNode.
-     */
-    getSuccessor(x: N): N | undefined;
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function returns the predecessor of a given node in a red-black tree.

package/dist/mjs/data-structures/binary-tree/rb-tree.js

@@ -86,6 +86,15 @@ export class RedBlackTree extends BST {
     isNode(exemplar) {
         return exemplar instanceof RedBlackTreeNode;
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof RedBlackTreeNode);
+    }
     /**
      * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
      * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
@@ -264,7 +273,9 @@ export class RedBlackTree extends BST {
      * Space Complexity: O(1)
      */
     isRealNode(node) {
-        return node !== this.Sentinel && node !== undefined;
+        if (node === this.Sentinel || node === undefined)
+            return false;
+        return node instanceof RedBlackTreeNode;
     }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
@@ -298,34 +309,11 @@ export class RedBlackTree extends BST {
         return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     *
-     * The function returns the successor of a given node in a red-black tree.
-     * @param {RedBlackTreeNode} x - RedBlackTreeNode - The node for which we want to find the successor.
-     * @returns the successor of the given RedBlackTreeNode.
-     */
-    getSuccessor(x) {
-        if (x.right !== this.Sentinel) {
-            return this.getLeftMost(x.right) ?? undefined;
-        }
-        let y = x.parent;
-        while (y !== this.Sentinel && y !== undefined && x === y.right) {
-            x = y;
-            y = y.parent;
-        }
-        return y;
-    }
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function returns the predecessor of a given node in a red-black tree.
@@ -334,11 +322,11 @@ export class RedBlackTree extends BST {
      * @returns the predecessor of the given RedBlackTreeNode 'x'.
      */
     getPredecessor(x) {
-        if (x.left !== this.Sentinel) {
+        if (this.isRealNode(x.left)) {
             return this.getRightMost(x.left);
         }
         let y = x.parent;
-        while (y !== this.Sentinel && x === y.left) {
+        while (this.isRealNode(y) && x === y.left) {
             x = y;
             y = y.parent;
         }

package/dist/mjs/data-structures/binary-tree/tree-multimap.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BSTNodeKeyOrNode, BTNodeExemplar, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
-import { BiTreeDeleteResult, BTNCallback, IterationType, TreeMultimapNested } from '../../types';
+import { BiTreeDeleteResult, BTNCallback, BTNodeKeyOrNode, IterationType, TreeMultimapNested } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNodeNested<K, V>> extends AVLTreeNode<K, V, N> {
@@ -48,6 +48,13 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * class.
      */
     isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
      * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, which means it

package/dist/mjs/data-structures/binary-tree/tree-multimap.js

@@ -60,6 +60,15 @@ export class TreeMultimap extends AVLTree {
     isNode(exemplar) {
         return exemplar instanceof TreeMultimapNode;
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof TreeMultimapNode);
+    }
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
      * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, which means it

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

@@ -439,113 +439,3 @@ export declare class Deque<E> extends IterableElementBase<E> {
         indexInBucket: number;
     };
 }
-export declare class ObjectDeque<E = number> {
-    constructor(capacity?: number);
-    protected _nodes: {
-        [key: number]: E;
-    };
-    get nodes(): {
-        [p: number]: E;
-    };
-    protected _capacity: number;
-    get capacity(): number;
-    protected _first: number;
-    get first(): number;
-    protected _last: number;
-    get last(): number;
-    protected _size: number;
-    get size(): number;
-    /**
-     * 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-like data structure.
-     * @param {E} element - The `element` parameter represents the element that you want to add to the beginning of the data
-     * structure.
-     */
-    addFirst(element: E): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addLast function adds an element to the end of an array-like data structure.
-     * @param {E} element - The `element` parameter represents the element that you want to add to the end of the data structure.
-     */
-    addLast(element: E): void;
-    /**
-     * 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 in a data structure.
-     * @returns The element of the first element in the data structure.
-     */
-    pollFirst(): E | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `getFirst` function returns the first element in an array-like data structure if it exists.
-     * @returns The element at the first position of the `_nodes` array.
-     */
-    getFirst(): E | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pollLast()` function removes and returns the last element in a data structure.
-     * @returns The element that was removed from the data structure.
-     */
-    pollLast(): E | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `getLast()` function returns the last element in an array-like data structure.
-     * @returns The last element in the array "_nodes" is being returned.
-     */
-    getLast(): E | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The get function returns the element at the specified index in an array-like data structure.
-     * @param {number} index - The index parameter is a number that represents the position of the element you want to
-     * retrieve from the array.
-     * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
-     * index, `undefined` is returned.
-     */
-    get(index: number): NonNullable<E> | undefined;
-    /**
-     * The function checks if the size of a data structure is less than or equal to zero.
-     * @returns The method is returning a boolean element indicating whether the size of the object is less than or equal to 0.
-     */
-    isEmpty(): boolean;
-}

package/dist/mjs/data-structures/queue/deque.js

@@ -789,173 +789,3 @@ export class Deque extends IterableElementBase {
         return { bucketIndex, indexInBucket };
     }
 }
-// O(1) time complexity of obtaining the element
-// O(n) time complexity of adding at the beginning and the end
-// todo tested slowest one
-export class ObjectDeque {
-    constructor(capacity) {
-        if (capacity !== undefined)
-            this._capacity = capacity;
-    }
-    _nodes = {};
-    get nodes() {
-        return this._nodes;
-    }
-    _capacity = Number.MAX_SAFE_INTEGER;
-    get capacity() {
-        return this._capacity;
-    }
-    _first = -1;
-    get first() {
-        return this._first;
-    }
-    _last = -1;
-    get last() {
-        return this._last;
-    }
-    _size = 0;
-    get size() {
-        return this._size;
-    }
-    /**
-     * 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-like data structure.
-     * @param {E} element - The `element` parameter represents the element that you want to add to the beginning of the data
-     * structure.
-     */
-    addFirst(element) {
-        if (this.size === 0) {
-            const mid = Math.floor(this.capacity / 2);
-            this._first = mid;
-            this._last = mid;
-        }
-        else {
-            this._first--;
-        }
-        this.nodes[this.first] = element;
-        this._size++;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addLast function adds an element to the end of an array-like data structure.
-     * @param {E} element - The `element` parameter represents the element that you want to add to the end of the data structure.
-     */
-    addLast(element) {
-        if (this.size === 0) {
-            const mid = Math.floor(this.capacity / 2);
-            this._first = mid;
-            this._last = mid;
-        }
-        else {
-            this._last++;
-        }
-        this.nodes[this.last] = element;
-        this._size++;
-    }
-    /**
-     * 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 in a data structure.
-     * @returns The element of the first element in the data structure.
-     */
-    pollFirst() {
-        if (!this.size)
-            return;
-        const element = this.getFirst();
-        delete this.nodes[this.first];
-        this._first++;
-        this._size--;
-        return element;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `getFirst` function returns the first element in an array-like data structure if it exists.
-     * @returns The element at the first position of the `_nodes` array.
-     */
-    getFirst() {
-        if (this.size)
-            return this.nodes[this.first];
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pollLast()` function removes and returns the last element in a data structure.
-     * @returns The element that was removed from the data structure.
-     */
-    pollLast() {
-        if (!this.size)
-            return;
-        const element = this.getLast();
-        delete this.nodes[this.last];
-        this._last--;
-        this._size--;
-        return element;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `getLast()` function returns the last element in an array-like data structure.
-     * @returns The last element in the array "_nodes" is being returned.
-     */
-    getLast() {
-        if (this.size)
-            return this.nodes[this.last];
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The get function returns the element at the specified index in an array-like data structure.
-     * @param {number} index - The index parameter is a number that represents the position of the element you want to
-     * retrieve from the array.
-     * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
-     * index, `undefined` is returned.
-     */
-    get(index) {
-        return this.nodes[this.first + index] || undefined;
-    }
-    /**
-     * The function checks if the size of a data structure is less than or equal to zero.
-     * @returns The method is returning a boolean element indicating whether the size of the object is less than or equal to 0.
-     */
-    isEmpty() {
-        return this.size <= 0;
-    }
-}