linked-list-typed 1.46.2 → 1.46.3

package/dist/data-structures/hash/hash-map.d.ts

@@ -5,48 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { HashMapLinkedNode, IterableWithSizeOrLength, IterateDirection } from '../../types';
-/**
- * Because the implementation of HashMap relies on JavaScript's built-in objects and arrays,
- * these underlying structures have already dealt with dynamic expansion and hash collisions.
- * Therefore, there is no need for additional logic to handle these issues.
- */
-export declare class HashMapIterator<K, V> {
-    readonly hashMap: HashMap<K, V>;
-    readonly iterateDirection: IterateDirection;
-    protected _node: HashMapLinkedNode<K, V>;
-    protected readonly _sentinel: HashMapLinkedNode<K, V>;
-    /**
-     * This is a constructor function for a linked list iterator in a HashMap data structure.
-     * @param node - The `node` parameter is a reference to a `HashMapLinkedNode` object. This object
-     * represents a node in a linked list used in a hash map data structure. It contains a key-value pair
-     * and references to the previous and next nodes in the linked list.
-     * @param sentinel - The `sentinel` parameter is a reference to a special node in a linked list. It
-     * is used to mark the beginning or end of the list and is typically used in data structures like
-     * hash maps or linked lists to simplify operations and boundary checks.
-     * @param hashMap - A HashMap object that stores key-value pairs.
-     * @param {IterateDirection} iterateDirection - The `iterateDirection` parameter is an optional
-     * parameter that specifies the direction in which the iterator should iterate over the elements of
-     * the HashMap. It can take one of the following values:
-     * @returns The constructor does not return anything. It is used to initialize the properties and
-     * methods of the object being created.
-     */
-    constructor(node: HashMapLinkedNode<K, V>, sentinel: HashMapLinkedNode<K, V>, hashMap: HashMap<K, V>, iterateDirection?: IterateDirection);
-    /**
-     * The above function returns a Proxy object that allows access to the key and value of a node in a
-     * data structure.
-     * @returns The code is returning a Proxy object.
-     */
-    get current(): [K, V];
-    /**
-     * The function checks if a node is accessible.
-     * @returns a boolean value indicating whether the `_node` is not equal to the `_sentinel`.
-     */
-    isAccessible(): boolean;
-    prev(): this;
-    next(): this;
-    clone(): HashMapIterator<K, V>;
-}
+import { HashMapLinkedNode, IterableWithSizeOrLength } from '../../types';
 export declare class HashMap<K = any, V = any> {
     readonly OBJ_KEY_INDEX: symbol;
     protected _nodes: HashMapLinkedNode<K, V>[];
@@ -63,41 +22,6 @@ export declare class HashMap<K = any, V = any> {
     constructor(elements?: IterableWithSizeOrLength<[K, V]>);
     protected _size: number;
     get size(): number;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns a new iterator object for a HashMap.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get begin(): HashMapIterator<K, V>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns a new HashMapIterator object with the _sentinel value as both the start and
-     * end values.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get end(): HashMapIterator<K, V>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
-     * a HashMap in reverse order.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get reverseBegin(): HashMapIterator<K, V>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
-     * HashMap in reverse order.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get reverseEnd(): HashMapIterator<K, V>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -116,6 +40,15 @@ export declare class HashMap<K = any, V = any> {
      * data structure.
      */
     get last(): [K, V] | undefined;
+    /**
+     * The `begin()` function in TypeScript iterates over a linked list and yields key-value pairs.
+     */
+    begin(): Generator<(K | V)[], void, unknown>;
+    /**
+     * The function `reverseBegin()` iterates over a linked list in reverse order, yielding each node's
+     * key and value.
+     */
+    reverseBegin(): Generator<(K | V)[], void, unknown>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -159,20 +92,6 @@ export declare class HashMap<K = any, V = any> {
      * where `K` is the key and `V` is the value.
      */
     getAt(index: number): [K, V];
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function `getIterator` returns a new instance of `HashMapIterator` based on the provided key
-     * and whether it is an object key or not.
-     * @param {K} key - The `key` parameter is the key used to retrieve the iterator from the HashMap. It
-     * can be of any type, depending on how the HashMap is implemented.
-     * @param {boolean} [isObjectKey] - The `isObjectKey` parameter is an optional boolean parameter that
-     * indicates whether the `key` parameter is an object key. If `isObjectKey` is `true`, it means that
-     * the `key` parameter is an object and needs to be handled differently. If `isObjectKey` is `false`
-     * @returns a new instance of the `HashMapIterator` class.
-     */
-    getIterator(key: K, isObjectKey?: boolean): HashMapIterator<K, V>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

package/dist/data-structures/hash/hash-map.js

@@ -7,113 +7,8 @@
  * @license MIT License
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HashMap = exports.HashMapIterator = void 0;
+exports.HashMap = void 0;
 const utils_1 = require("../../utils");
-/**
- * Because the implementation of HashMap relies on JavaScript's built-in objects and arrays,
- * these underlying structures have already dealt with dynamic expansion and hash collisions.
- * Therefore, there is no need for additional logic to handle these issues.
- */
-class HashMapIterator {
-    /**
-     * This is a constructor function for a linked list iterator in a HashMap data structure.
-     * @param node - The `node` parameter is a reference to a `HashMapLinkedNode` object. This object
-     * represents a node in a linked list used in a hash map data structure. It contains a key-value pair
-     * and references to the previous and next nodes in the linked list.
-     * @param sentinel - The `sentinel` parameter is a reference to a special node in a linked list. It
-     * is used to mark the beginning or end of the list and is typically used in data structures like
-     * hash maps or linked lists to simplify operations and boundary checks.
-     * @param hashMap - A HashMap object that stores key-value pairs.
-     * @param {IterateDirection} iterateDirection - The `iterateDirection` parameter is an optional
-     * parameter that specifies the direction in which the iterator should iterate over the elements of
-     * the HashMap. It can take one of the following values:
-     * @returns The constructor does not return anything. It is used to initialize the properties and
-     * methods of the object being created.
-     */
-    constructor(node, sentinel, hashMap, iterateDirection = 0 /* IterateDirection.DEFAULT */) {
-        this._node = node;
-        this._sentinel = sentinel;
-        this.iterateDirection = iterateDirection;
-        if (this.iterateDirection === 0 /* IterateDirection.DEFAULT */) {
-            this.prev = function () {
-                if (this._node.prev === this._sentinel) {
-                    (0, utils_1.throwRangeError)();
-                }
-                this._node = this._node.prev;
-                return this;
-            };
-            this.next = function () {
-                if (this._node === this._sentinel) {
-                    (0, utils_1.throwRangeError)();
-                }
-                this._node = this._node.next;
-                return this;
-            };
-        }
-        else {
-            this.prev = function () {
-                if (this._node.next === this._sentinel) {
-                    (0, utils_1.throwRangeError)();
-                }
-                this._node = this._node.next;
-                return this;
-            };
-            this.next = function () {
-                if (this._node === this._sentinel) {
-                    (0, utils_1.throwRangeError)();
-                }
-                this._node = this._node.prev;
-                return this;
-            };
-        }
-        this.hashMap = hashMap;
-    }
-    /**
-     * The above function returns a Proxy object that allows access to the key and value of a node in a
-     * data structure.
-     * @returns The code is returning a Proxy object.
-     */
-    get current() {
-        if (this._node === this._sentinel) {
-            (0, utils_1.throwRangeError)();
-        }
-        return new Proxy([], {
-            get: (target, prop) => {
-                if (prop === '0')
-                    return this._node.key;
-                else if (prop === '1')
-                    return this._node.value;
-                target[0] = this._node.key;
-                target[1] = this._node.value;
-                return target[prop];
-            },
-            set: (_, prop, newValue) => {
-                if (prop !== '1') {
-                    throw new TypeError(`prop should be string '1'`);
-                }
-                this._node.value = newValue;
-                return true;
-            }
-        });
-    }
-    /**
-     * The function checks if a node is accessible.
-     * @returns a boolean value indicating whether the `_node` is not equal to the `_sentinel`.
-     */
-    isAccessible() {
-        return this._node !== this._sentinel;
-    }
-    prev() {
-        return this;
-    }
-    next() {
-        return this;
-    }
-    clone() {
-        return new HashMapIterator(this._node, this._sentinel, this.hashMap, this.iterateDirection);
-    }
-}
-exports.HashMapIterator = HashMapIterator;
 class HashMap {
     /**
      * The constructor initializes a HashMap object with an optional initial set of key-value pairs.
@@ -136,49 +31,6 @@ class HashMap {
     get size() {
         return this._size;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns a new iterator object for a HashMap.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get begin() {
-        return new HashMapIterator(this._head, this._sentinel, this);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns a new HashMapIterator object with the _sentinel value as both the start and
-     * end values.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get end() {
-        return new HashMapIterator(this._sentinel, this._sentinel, this);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
-     * a HashMap in reverse order.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get reverseBegin() {
-        return new HashMapIterator(this._tail, this._sentinel, this, 1 /* IterateDirection.REVERSE */);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
-     * HashMap in reverse order.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get reverseEnd() {
-        return new HashMapIterator(this._sentinel, this._sentinel, this, 1 /* IterateDirection.REVERSE */);
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -205,6 +57,27 @@ class HashMap {
             return;
         return [this._tail.key, this._tail.value];
     }
+    /**
+     * The `begin()` function in TypeScript iterates over a linked list and yields key-value pairs.
+     */
+    *begin() {
+        let node = this._head;
+        while (node !== this._sentinel) {
+            yield [node.key, node.value];
+            node = node.next;
+        }
+    }
+    /**
+     * The function `reverseBegin()` iterates over a linked list in reverse order, yielding each node's
+     * key and value.
+     */
+    *reverseBegin() {
+        let node = this._tail;
+        while (node !== this._sentinel) {
+            yield [node.key, node.value];
+            node = node.prev;
+        }
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -305,35 +178,6 @@ class HashMap {
         }
         return [node.key, node.value];
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function `getIterator` returns a new instance of `HashMapIterator` based on the provided key
-     * and whether it is an object key or not.
-     * @param {K} key - The `key` parameter is the key used to retrieve the iterator from the HashMap. It
-     * can be of any type, depending on how the HashMap is implemented.
-     * @param {boolean} [isObjectKey] - The `isObjectKey` parameter is an optional boolean parameter that
-     * indicates whether the `key` parameter is an object key. If `isObjectKey` is `true`, it means that
-     * the `key` parameter is an object and needs to be handled differently. If `isObjectKey` is `false`
-     * @returns a new instance of the `HashMapIterator` class.
-     */
-    getIterator(key, isObjectKey) {
-        let node;
-        if (isObjectKey) {
-            const index = key[this.OBJ_KEY_INDEX];
-            if (index === undefined) {
-                node = this._sentinel;
-            }
-            else {
-                node = this._nodes[index];
-            }
-        }
-        else {
-            node = this._orgMap[key] || this._sentinel;
-        }
-        return new HashMapIterator(node, this._sentinel, this);
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -5,39 +5,13 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { IterableWithSizeOrLength, IterateDirection } from "../../types";
+import { IterableWithSizeOrLength } from "../../types";
 /**
  * Deque can provide random access with O(1) time complexity
  * Deque is usually more compact and efficient in memory usage because it does not require additional space to store pointers.
  * Deque may experience performance jitter, but DoublyLinkedList will not
  * Deque is implemented using a dynamic array. Inserting or deleting beyond both ends of the array may require moving elements or reallocating space.
  */
-export declare class DequeIterator<E> {
-    iterateDirection: IterateDirection;
-    index: number;
-    readonly deque: Deque<E>;
-    /**
-     * The constructor initializes the index, iterate direction, and prev/next functions for a
-     * DequeIterator object.
-     * @param {number} index - The index parameter represents the current index position of the iterator
-     * within the deque. It is a number that indicates the position of the element that the iterator is
-     * currently pointing to.
-     * @param deque - The `deque` parameter is an instance of the `Deque` class. It represents a
-     * double-ended queue data structure, which allows elements to be added or removed from both ends.
-     * @param iterateDirection - The `iterateDirection` parameter is an optional parameter that specifies
-     * the direction in which the iterator should iterate over the elements of the `deque`. It has a
-     * default value of `IterateDirection.DEFAULT`.
-     * @returns The constructor is not returning anything. It is used to initialize the properties of the
-     * object being created.
-     */
-    constructor(index: number, deque: Deque<E>, iterateDirection?: IterateDirection);
-    get current(): E;
-    set current(newElement: E);
-    isAccessible(): boolean;
-    prev(): DequeIterator<E>;
-    next(): DequeIterator<E>;
-    clone(): DequeIterator<E>;
-}
 export declare class Deque<E> {
     protected _bucketFirst: number;
     protected _firstInBucket: number;
@@ -120,28 +94,14 @@ export declare class Deque<E> {
      */
     clear(): void;
     /**
-     * The `begin()` function returns a new iterator for a deque starting from the first element.
-     * @returns A new instance of the DequeIterator class is being returned.
-     */
-    begin(): DequeIterator<E>;
-    /**
-     * The `end()` function returns a new `DequeIterator` object with the size and reference to the
-     * current deque.
-     * @returns A new instance of the DequeIterator class is being returned.
+     * The below function is a generator that yields elements from a collection one by one.
      */
-    end(): DequeIterator<E>;
+    begin(): Generator<E>;
     /**
-     * The reverseBegin function returns a new DequeIterator object that starts at the last element of
-     * the deque and iterates in reverse direction.
-     * @returns A new instance of the DequeIterator class is being returned.
+     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
+     * the last element.
      */
-    reverseBegin(): DequeIterator<E>;
-    /**
-     * The reverseEnd() function returns a new DequeIterator object that iterates over the elements of a
-     * Deque in reverse order.
-     * @returns A new instance of the DequeIterator class is being returned.
-     */
-    reverseEnd(): DequeIterator<E>;
+    reverseBegin(): Generator<E>;
     /**
      * Time Complexity - Amortized O(1) (possible reallocation)
      * Space Complexity - O(n) (due to potential resizing).
@@ -294,34 +254,6 @@ export declare class Deque<E> {
      * @returns The size of the data structure after the element has been deleted.
      */
     delete(element: E): number;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function deletes an element from a deque using an iterator and returns the next iterator.
-     * @param iter - The parameter `iter` is of type `DequeIterator<E>`. It represents an iterator object
-     * that is used to iterate over elements in a deque (double-ended queue).
-     * @returns the updated iterator after deleting an element from the deque.
-     */
-    deleteByIterator(iter: DequeIterator<E>): DequeIterator<E>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function `findIterator` searches for an element in a deque and returns an iterator pointing to
-     * the element if found, otherwise it returns an iterator pointing to the end of the deque.
-     * @param {E} element - The `element` parameter is the element that you want to find in the deque.
-     * @returns The method `findIterator(element: E)` returns a `DequeIterator<E>` object.
-     */
-    findIterator(element: E): DequeIterator<E>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)

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

@@ -7,7 +7,7 @@
  * @license MIT License
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectDeque = exports.Deque = exports.DequeIterator = void 0;
+exports.ObjectDeque = exports.Deque = void 0;
 const utils_1 = require("../../utils");
 /**
  * Deque can provide random access with O(1) time complexity
@@ -15,78 +15,6 @@ const utils_1 = require("../../utils");
  * Deque may experience performance jitter, but DoublyLinkedList will not
  * Deque is implemented using a dynamic array. Inserting or deleting beyond both ends of the array may require moving elements or reallocating space.
  */
-class DequeIterator {
-    /**
-     * The constructor initializes the index, iterate direction, and prev/next functions for a
-     * DequeIterator object.
-     * @param {number} index - The index parameter represents the current index position of the iterator
-     * within the deque. It is a number that indicates the position of the element that the iterator is
-     * currently pointing to.
-     * @param deque - The `deque` parameter is an instance of the `Deque` class. It represents a
-     * double-ended queue data structure, which allows elements to be added or removed from both ends.
-     * @param iterateDirection - The `iterateDirection` parameter is an optional parameter that specifies
-     * the direction in which the iterator should iterate over the elements of the `deque`. It has a
-     * default value of `IterateDirection.DEFAULT`.
-     * @returns The constructor is not returning anything. It is used to initialize the properties of the
-     * object being created.
-     */
-    constructor(index, deque, iterateDirection = 0 /* IterateDirection.DEFAULT */) {
-        this.index = index;
-        this.iterateDirection = iterateDirection;
-        if (this.iterateDirection === 0 /* IterateDirection.DEFAULT */) {
-            this.prev = function () {
-                if (this.index === 0) {
-                    (0, utils_1.throwRangeError)();
-                }
-                this.index -= 1;
-                return this;
-            };
-            this.next = function () {
-                if (this.index === this.deque.size) {
-                    (0, utils_1.throwRangeError)();
-                }
-                this.index += 1;
-                return this;
-            };
-        }
-        else {
-            this.prev = function () {
-                if (this.index === this.deque.size - 1) {
-                    (0, utils_1.throwRangeError)();
-                }
-                this.index += 1;
-                return this;
-            };
-            this.next = function () {
-                if (this.index === -1) {
-                    (0, utils_1.throwRangeError)();
-                }
-                this.index -= 1;
-                return this;
-            };
-        }
-        this.deque = deque;
-    }
-    get current() {
-        return this.deque.getAt(this.index);
-    }
-    set current(newElement) {
-        this.deque.setAt(this.index, newElement);
-    }
-    isAccessible() {
-        return this.index !== this.deque.size;
-    }
-    prev() {
-        return this;
-    }
-    next() {
-        return this;
-    }
-    clone() {
-        return new DequeIterator(this.index, this.deque, this.iterateDirection);
-    }
-}
-exports.DequeIterator = DequeIterator;
 class Deque {
     /**
      * The constructor initializes a data structure with a specified bucket size and populates it with
@@ -220,35 +148,25 @@ class Deque {
         this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
     }
     /**
-     * The `begin()` function returns a new iterator for a deque starting from the first element.
-     * @returns A new instance of the DequeIterator class is being returned.
-     */
-    begin() {
-        return new DequeIterator(0, this);
-    }
-    /**
-     * The `end()` function returns a new `DequeIterator` object with the size and reference to the
-     * current deque.
-     * @returns A new instance of the DequeIterator class is being returned.
+     * The below function is a generator that yields elements from a collection one by one.
      */
-    end() {
-        return new DequeIterator(this.size, this);
-    }
-    /**
-     * The reverseBegin function returns a new DequeIterator object that starts at the last element of
-     * the deque and iterates in reverse direction.
-     * @returns A new instance of the DequeIterator class is being returned.
-     */
-    reverseBegin() {
-        return new DequeIterator(this.size - 1, this, 1 /* IterateDirection.REVERSE */);
+    *begin() {
+        let index = 0;
+        while (index < this.size) {
+            yield this.getAt(index);
+            index++;
+        }
     }
     /**
-     * The reverseEnd() function returns a new DequeIterator object that iterates over the elements of a
-     * Deque in reverse order.
-     * @returns A new instance of the DequeIterator class is being returned.
+     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
+     * the last element.
      */
-    reverseEnd() {
-        return new DequeIterator(-1, this, 1 /* IterateDirection.REVERSE */);
+    *reverseBegin() {
+        let index = this.size - 1;
+        while (index >= 0) {
+            yield this.getAt(index);
+            index--;
+        }
     }
     /**
      * Time Complexity - Amortized O(1) (possible reallocation)
@@ -399,7 +317,7 @@ class Deque {
      * @returns The element at the specified position in the data structure is being returned.
      */
     getAt(pos) {
-        utils_1.rangeCheck(pos, 0, this.size - 1);
+        (0, utils_1.rangeCheck)(pos, 0, this.size - 1);
         const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
         return this._buckets[bucketIndex][indexInBucket];
     }
@@ -418,7 +336,7 @@ class Deque {
      * position in the data structure.
      */
     setAt(pos, element) {
-        utils_1.rangeCheck(pos, 0, this.size - 1);
+        (0, utils_1.rangeCheck)(pos, 0, this.size - 1);
         const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
         this._buckets[bucketIndex][indexInBucket] = element;
     }
@@ -443,7 +361,7 @@ class Deque {
      */
     insertAt(pos, element, num = 1) {
         const length = this.size;
-        utils_1.rangeCheck(pos, 0, length);
+        (0, utils_1.rangeCheck)(pos, 0, length);
         if (pos === 0) {
             while (num--)
                 this.unshift(element);
@@ -506,7 +424,7 @@ class Deque {
      * @returns The size of the data structure after the deletion operation is performed.
      */
     deleteAt(pos) {
-        utils_1.rangeCheck(pos, 0, this.size - 1);
+        (0, utils_1.rangeCheck)(pos, 0, this.size - 1);
         if (pos === 0)
             this.shift();
         else if (pos === this.size - 1)
@@ -555,46 +473,6 @@ class Deque {
         this.cut(index - 1);
         return this.size;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function deletes an element from a deque using an iterator and returns the next iterator.
-     * @param iter - The parameter `iter` is of type `DequeIterator<E>`. It represents an iterator object
-     * that is used to iterate over elements in a deque (double-ended queue).
-     * @returns the updated iterator after deleting an element from the deque.
-     */
-    deleteByIterator(iter) {
-        const index = iter.index;
-        this.deleteAt(index);
-        iter = iter.next();
-        return iter;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function `findIterator` searches for an element in a deque and returns an iterator pointing to
-     * the element if found, otherwise it returns an iterator pointing to the end of the deque.
-     * @param {E} element - The `element` parameter is the element that you want to find in the deque.
-     * @returns The method `findIterator(element: E)` returns a `DequeIterator<E>` object.
-     */
-    findIterator(element) {
-        for (let i = 0; i < this.size; ++i) {
-            if (this.getAt(i) === element) {
-                return new DequeIterator(i, this);
-            }
-        }
-        return this.end();
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-list-typed",
-  "version": "1.46.2",
+  "version": "1.46.3",
   "description": "Linked List, Doubly Linked List, Singly Linked List. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -66,6 +66,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.46.2"
+    "data-structure-typed": "^1.46.3"
   }
 }

package/src/data-structures/hash/hash-map.ts

@@ -6,127 +6,8 @@
  * @license MIT License
  */
 
-import { isObjOrFunc, rangeCheck, throwRangeError } from '../../utils';
-import { HashMapLinkedNode, IterableWithSizeOrLength, IterateDirection } from '../../types';
-
-/**
- * Because the implementation of HashMap relies on JavaScript's built-in objects and arrays,
- * these underlying structures have already dealt with dynamic expansion and hash collisions.
- * Therefore, there is no need for additional logic to handle these issues.
- */
-export class HashMapIterator<K, V> {
-  readonly hashMap: HashMap<K, V>;
-  readonly iterateDirection: IterateDirection;
-  protected _node: HashMapLinkedNode<K, V>;
-  protected readonly _sentinel: HashMapLinkedNode<K, V>;
-
-  /**
-   * This is a constructor function for a linked list iterator in a HashMap data structure.
-   * @param node - The `node` parameter is a reference to a `HashMapLinkedNode` object. This object
-   * represents a node in a linked list used in a hash map data structure. It contains a key-value pair
-   * and references to the previous and next nodes in the linked list.
-   * @param sentinel - The `sentinel` parameter is a reference to a special node in a linked list. It
-   * is used to mark the beginning or end of the list and is typically used in data structures like
-   * hash maps or linked lists to simplify operations and boundary checks.
-   * @param hashMap - A HashMap object that stores key-value pairs.
-   * @param {IterateDirection} iterateDirection - The `iterateDirection` parameter is an optional
-   * parameter that specifies the direction in which the iterator should iterate over the elements of
-   * the HashMap. It can take one of the following values:
-   * @returns The constructor does not return anything. It is used to initialize the properties and
-   * methods of the object being created.
-   */
-  constructor(
-    node: HashMapLinkedNode<K, V>,
-    sentinel: HashMapLinkedNode<K, V>,
-    hashMap: HashMap<K, V>,
-    iterateDirection: IterateDirection = IterateDirection.DEFAULT
-  ) {
-    this._node = node;
-    this._sentinel = sentinel;
-    this.iterateDirection = iterateDirection;
-
-    if (this.iterateDirection === IterateDirection.DEFAULT) {
-      this.prev = function () {
-        if (this._node.prev === this._sentinel) {
-          throwRangeError();
-        }
-        this._node = this._node.prev;
-        return this;
-      };
-      this.next = function () {
-        if (this._node === this._sentinel) {
-          throwRangeError();
-        }
-        this._node = this._node.next;
-        return this;
-      };
-    } else {
-      this.prev = function () {
-        if (this._node.next === this._sentinel) {
-          throwRangeError();
-        }
-        this._node = this._node.next;
-        return this;
-      };
-      this.next = function () {
-        if (this._node === this._sentinel) {
-          throwRangeError();
-        }
-        this._node = this._node.prev;
-        return this;
-      };
-    }
-    this.hashMap = hashMap;
-  }
-
-  /**
-   * The above function returns a Proxy object that allows access to the key and value of a node in a
-   * data structure.
-   * @returns The code is returning a Proxy object.
-   */
-  get current() {
-    if (this._node === this._sentinel) {
-      throwRangeError();
-    }
-
-    return new Proxy(<[K, V]>(<unknown>[]), {
-      get: (target, prop: '0' | '1') => {
-        if (prop === '0') return this._node.key;
-        else if (prop === '1') return this._node.value;
-        target[0] = this._node.key;
-        target[1] = this._node.value;
-        return target[prop];
-      },
-      set: (_, prop: '1', newValue: V) => {
-        if (prop !== '1') {
-          throw new TypeError(`prop should be string '1'`);
-        }
-        this._node.value = newValue;
-        return true;
-      }
-    });
-  }
-
-  /**
-   * The function checks if a node is accessible.
-   * @returns a boolean value indicating whether the `_node` is not equal to the `_sentinel`.
-   */
-  isAccessible() {
-    return this._node !== this._sentinel;
-  }
-
-  prev() {
-    return this;
-  }
-
-  next() {
-    return this;
-  }
-
-  clone() {
-    return new HashMapIterator<K, V>(this._node, this._sentinel, this.hashMap, this.iterateDirection)
-  }
-}
+import { isObjOrFunc, rangeCheck } from '../../utils';
+import { HashMapLinkedNode, IterableWithSizeOrLength } from '../../types';
 
 export class HashMap<K = any, V = any> {
   readonly OBJ_KEY_INDEX = Symbol('OBJ_KEY_INDEX');
@@ -158,53 +39,6 @@ export class HashMap<K = any, V = any> {
     return this._size;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns a new iterator object for a HashMap.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get begin() {
-    return new HashMapIterator<K, V>(this._head, this._sentinel, this);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns a new HashMapIterator object with the _sentinel value as both the start and
-   * end values.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get end() {
-    return new HashMapIterator<K, V>(this._sentinel, this._sentinel, this);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
-   * a HashMap in reverse order.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get reverseBegin() {
-    return new HashMapIterator<K, V>(this._tail, this._sentinel, this, IterateDirection.REVERSE);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
-   * HashMap in reverse order.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get reverseEnd() {
-    return new HashMapIterator<K, V>(this._sentinel, this._sentinel, this, IterateDirection.REVERSE);
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -231,6 +65,29 @@ export class HashMap<K = any, V = any> {
     return <[K, V]>[this._tail.key, this._tail.value];
   }
 
+  /**
+   * The `begin()` function in TypeScript iterates over a linked list and yields key-value pairs.
+   */
+  * begin() {
+    let node = this._head;
+    while (node !== this._sentinel) {
+      yield [node.key, node.value];
+      node = node.next;
+    }
+  }
+
+  /**
+   * The function `reverseBegin()` iterates over a linked list in reverse order, yielding each node's
+   * key and value.
+   */
+  * reverseBegin() {
+    let node = this._tail;
+    while (node !== this._sentinel) {
+      yield [node.key, node.value];
+      node = node.prev;
+    }
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -332,34 +189,6 @@ export class HashMap<K = any, V = any> {
     return <[K, V]>[node.key, node.value];
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `getIterator` returns a new instance of `HashMapIterator` based on the provided key
-   * and whether it is an object key or not.
-   * @param {K} key - The `key` parameter is the key used to retrieve the iterator from the HashMap. It
-   * can be of any type, depending on how the HashMap is implemented.
-   * @param {boolean} [isObjectKey] - The `isObjectKey` parameter is an optional boolean parameter that
-   * indicates whether the `key` parameter is an object key. If `isObjectKey` is `true`, it means that
-   * the `key` parameter is an object and needs to be handled differently. If `isObjectKey` is `false`
-   * @returns a new instance of the `HashMapIterator` class.
-   */
-  getIterator(key: K, isObjectKey?: boolean) {
-    let node: HashMapLinkedNode<K, V>;
-    if (isObjectKey) {
-      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
-      if (index === undefined) {
-        node = this._sentinel;
-      } else {
-        node = this._nodes[index];
-      }
-    } else {
-      node = this._orgMap[<string>(<unknown>key)] || this._sentinel;
-    }
-    return new HashMapIterator<K, V>(node, this._sentinel, this);
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)

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

@@ -7,8 +7,8 @@
  */
 
 
-import { IterableWithSizeOrLength, IterateDirection } from "../../types";
-import { calcMinUnitsRequired, rangeCheck, throwRangeError } from "../../utils";
+import { IterableWithSizeOrLength } from "../../types";
+import { calcMinUnitsRequired, rangeCheck } from "../../utils";
 
 /**
  * Deque can provide random access with O(1) time complexity
@@ -17,89 +17,6 @@ import { calcMinUnitsRequired, rangeCheck, throwRangeError } from "../../utils";
  * Deque is implemented using a dynamic array. Inserting or deleting beyond both ends of the array may require moving elements or reallocating space.
  */
 
-export class DequeIterator<E> {
-  iterateDirection: IterateDirection;
-
-  index: number;
-  readonly deque: Deque<E>;
-
-  /**
-   * The constructor initializes the index, iterate direction, and prev/next functions for a
-   * DequeIterator object.
-   * @param {number} index - The index parameter represents the current index position of the iterator
-   * within the deque. It is a number that indicates the position of the element that the iterator is
-   * currently pointing to.
-   * @param deque - The `deque` parameter is an instance of the `Deque` class. It represents a
-   * double-ended queue data structure, which allows elements to be added or removed from both ends.
-   * @param iterateDirection - The `iterateDirection` parameter is an optional parameter that specifies
-   * the direction in which the iterator should iterate over the elements of the `deque`. It has a
-   * default value of `IterateDirection.DEFAULT`.
-   * @returns The constructor is not returning anything. It is used to initialize the properties of the
-   * object being created.
-   */
-  constructor(index: number, deque: Deque<E>, iterateDirection = IterateDirection.DEFAULT) {
-    this.index = index;
-    this.iterateDirection = iterateDirection;
-    if (this.iterateDirection === IterateDirection.DEFAULT) {
-      this.prev = function () {
-        if (this.index === 0) {
-          throwRangeError();
-        }
-        this.index -= 1;
-        return this;
-      };
-      this.next = function () {
-        if (this.index === this.deque.size) {
-          throwRangeError();
-        }
-        this.index += 1;
-        return this;
-      };
-    } else {
-      this.prev = function () {
-        if (this.index === this.deque.size - 1) {
-          throwRangeError();
-        }
-        this.index += 1;
-        return this;
-      };
-      this.next = function () {
-        if (this.index === -1) {
-          throwRangeError();
-        }
-        this.index -= 1;
-        return this;
-      };
-    }
-    this.deque = deque;
-  }
-
-  get current() {
-    return this.deque.getAt(this.index);
-  }
-
-  set current(newElement: E) {
-    this.deque.setAt(this.index, newElement);
-  }
-
-  isAccessible() {
-    return this.index !== this.deque.size;
-  }
-
-  prev(): DequeIterator<E> {
-    return this;
-  }
-
-  next(): DequeIterator<E> {
-    return this;
-  }
-
-  clone() {
-    return new DequeIterator<E>(this.index, this.deque, this.iterateDirection);
-  }
-
-}
-
 export class Deque<E> {
   protected _bucketFirst = 0;
   protected _firstInBucket = 0;
@@ -123,7 +40,7 @@ export class Deque<E> {
     if ('length' in elements) {
       if (elements.length instanceof Function) _size = elements.length(); else _size = elements.length;
     } else {
-      if (elements.size instanceof Function) _size = elements.size();else _size = elements.size;
+      if (elements.size instanceof Function) _size = elements.size(); else _size = elements.size;
     }
 
     this._bucketSize = bucketSize;
@@ -245,38 +162,26 @@ export class Deque<E> {
   }
 
   /**
-   * The `begin()` function returns a new iterator for a deque starting from the first element.
-   * @returns A new instance of the DequeIterator class is being returned.
-   */
-  begin() {
-    return new DequeIterator<E>(0, this);
-  }
-
-  /**
-   * The `end()` function returns a new `DequeIterator` object with the size and reference to the
-   * current deque.
-   * @returns A new instance of the DequeIterator class is being returned.
+   * The below function is a generator that yields elements from a collection one by one.
    */
-  end() {
-    return new DequeIterator<E>(this.size, this);
-  }
-
-  /**
-   * The reverseBegin function returns a new DequeIterator object that starts at the last element of
-   * the deque and iterates in reverse direction.
-   * @returns A new instance of the DequeIterator class is being returned.
-   */
-  reverseBegin() {
-    return new DequeIterator<E>(this.size - 1, this, IterateDirection.REVERSE);
+  * begin(): Generator<E> {
+    let index = 0;
+    while (index < this.size) {
+      yield this.getAt(index);
+      index++;
+    }
   }
 
   /**
-   * The reverseEnd() function returns a new DequeIterator object that iterates over the elements of a
-   * Deque in reverse order.
-   * @returns A new instance of the DequeIterator class is being returned.
+   * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
+   * the last element.
    */
-  reverseEnd() {
-    return new DequeIterator<E>(-1, this, IterateDirection.REVERSE);
+  * reverseBegin(): Generator<E> {
+    let index = this.size - 1;
+    while (index >= 0) {
+      yield this.getAt(index);
+      index--;
+    }
   }
 
   /**
@@ -431,7 +336,7 @@ export class Deque<E> {
    * @returns The element at the specified position in the data structure is being returned.
    */
   getAt(pos: number): E {
-    rangeCheck!(pos, 0, this.size - 1);
+    rangeCheck(pos, 0, this.size - 1);
     const {
       bucketIndex,
       indexInBucket
@@ -456,7 +361,7 @@ export class Deque<E> {
    * position in the data structure.
    */
   setAt(pos: number, element: E) {
-    rangeCheck!(pos, 0, this.size - 1);
+    rangeCheck(pos, 0, this.size - 1);
     const {
       bucketIndex,
       indexInBucket
@@ -486,7 +391,7 @@ export class Deque<E> {
    */
   insertAt(pos: number, element: E, num = 1) {
     const length = this.size;
-    rangeCheck!(pos, 0, length);
+    rangeCheck(pos, 0, length);
     if (pos === 0) {
       while (num--) this.unshift(element);
     } else if (pos === this.size) {
@@ -550,7 +455,7 @@ export class Deque<E> {
    * @returns The size of the data structure after the deletion operation is performed.
    */
   deleteAt(pos: number) {
-    rangeCheck!(pos, 0, this.size - 1);
+    rangeCheck(pos, 0, this.size - 1);
     if (pos === 0) this.shift();
     else if (pos === this.size - 1) this.pop();
     else {
@@ -605,50 +510,6 @@ export class Deque<E> {
     return this.size;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function deletes an element from a deque using an iterator and returns the next iterator.
-   * @param iter - The parameter `iter` is of type `DequeIterator<E>`. It represents an iterator object
-   * that is used to iterate over elements in a deque (double-ended queue).
-   * @returns the updated iterator after deleting an element from the deque.
-   */
-  deleteByIterator(iter: DequeIterator<E>) {
-    const index = iter.index;
-    this.deleteAt(index);
-    iter = iter.next();
-    return iter;
-  }
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function `findIterator` searches for an element in a deque and returns an iterator pointing to
-   * the element if found, otherwise it returns an iterator pointing to the end of the deque.
-   * @param {E} element - The `element` parameter is the element that you want to find in the deque.
-   * @returns The method `findIterator(element: E)` returns a `DequeIterator<E>` object.
-   */
-  findIterator(element: E) {
-    for (let i = 0; i < this.size; ++i) {
-      if (this.getAt(i) === element) {
-        return new DequeIterator<E>(i, this);
-      }
-    }
-    return this.end();
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)