data-structure-typed 1.49.0 → 1.49.2

package/dist/mjs/data-structures/linked-list/doubly-linked-list.js

@@ -1,11 +1,4 @@
-import { IterableElementBase } from "../base";
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
+import { IterableElementBase } from '../base';
 export class DoublyLinkedListNode {
     value;
     next;
@@ -21,15 +14,21 @@ export class DoublyLinkedListNode {
         this.prev = undefined;
     }
 }
+/**
+ * 1. Node Structure: Each node contains three parts: a data field, a pointer (or reference) to the previous node, and a pointer to the next node. This structure allows traversal of the linked list in both directions.
+ * 2. Bidirectional Traversal: Unlike singly linked lists, doubly linked lists can be easily traversed forwards or backwards. This makes insertions and deletions in the list more flexible and efficient.
+ * 3. No Centralized Index: Unlike arrays, elements in a linked list are not stored contiguously, so there is no centralized index. Accessing elements in a linked list typically requires traversing from the head or tail node.
+ * 4. High Efficiency in Insertion and Deletion: Adding or removing elements in a linked list does not require moving other elements, making these operations more efficient than in arrays.
+ */
 export class DoublyLinkedList extends IterableElementBase {
     /**
-     * The constructor initializes the linked list with an empty head, tail, and length.
+     * The constructor initializes the linked list with an empty head, tail, and size.
      */
     constructor(elements) {
         super();
         this._head = undefined;
         this._tail = undefined;
-        this._length = 0;
+        this._size = 0;
         if (elements) {
             for (const el of elements) {
                 this.push(el);
@@ -44,19 +43,16 @@ export class DoublyLinkedList extends IterableElementBase {
     get tail() {
         return this._tail;
     }
-    _length;
-    get length() {
-        return this._length;
-    }
+    _size;
     get size() {
-        return this.length;
+        return this._size;
     }
     /**
-     * Time Complexity: O(n), where n is the length of the input array.
+     * Time Complexity: O(n), where n is the size of the input array.
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the length of the input array.
+     * Time Complexity: O(n), where n is the size of the input array.
      * Space Complexity: O(n)
      *
      * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
@@ -93,21 +89,8 @@ export class DoublyLinkedList extends IterableElementBase {
             this.tail.next = newNode;
             this._tail = newNode;
         }
-        this._length++;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addLast function adds a new node with the given value to the end of the doubly linked list.
-     * @param {E} value - The value to be added to the linked list.
-     */
-    addLast(value) {
-        this.push(value);
+        this._size++;
+        return true;
     }
     /**
      * Time Complexity: O(1)
@@ -133,24 +116,9 @@ export class DoublyLinkedList extends IterableElementBase {
             this._tail = removedNode.prev;
             this.tail.next = undefined;
         }
-        this._length--;
+        this._size--;
         return removedNode.value;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
-     * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
-     * list is empty, it returns undefined.
-     */
-    pollLast() {
-        return this.pop();
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -175,24 +143,9 @@ export class DoublyLinkedList extends IterableElementBase {
             this._head = removedNode.next;
             this.head.prev = undefined;
         }
-        this._length--;
+        this._size--;
         return removedNode.value;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
-     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
-     * list.
-     */
-    pollFirst() {
-        return this.shift();
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -216,50 +169,8 @@ export class DoublyLinkedList extends IterableElementBase {
             this.head.prev = newNode;
             this._head = newNode;
         }
-        this._length++;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addFirst function adds a new node with the given value to the beginning of a doubly linked list.
-     * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
-     * doubly linked list.
-     */
-    addFirst(value) {
-        this.unshift(value);
-    }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     *
-     * The `getFirst` function returns the first node in a doubly linked list, or undefined if the list is empty.
-     * @returns The method `getFirst()` returns the first node of the doubly linked list, or `undefined` if the list is empty.
-     */
-    getFirst() {
-        return this.head?.value;
-    }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     *
-     * The `getLast` function returns the last node in a doubly linked list, or undefined if the list is empty.
-     * @returns The method `getLast()` returns the last node of the doubly linked list, or `undefined` if the list is empty.
-     */
-    getLast() {
-        return this.tail?.value;
+        this._size++;
+        return true;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -276,7 +187,7 @@ export class DoublyLinkedList extends IterableElementBase {
      * or the linked list is empty, it will return undefined.
      */
     getAt(index) {
-        if (index < 0 || index >= this.length)
+        if (index < 0 || index >= this.size)
             return undefined;
         let current = this.head;
         for (let i = 0; i < index; i++) {
@@ -300,7 +211,7 @@ export class DoublyLinkedList extends IterableElementBase {
      * valid range of the linked list, otherwise it returns `undefined`.
      */
     getNodeAt(index) {
-        if (index < 0 || index >= this.length)
+        if (index < 0 || index >= this.size)
             return undefined;
         let current = this.head;
         for (let i = 0; i < index; i++) {
@@ -348,14 +259,14 @@ export class DoublyLinkedList extends IterableElementBase {
      * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
      * if the index is out of bounds.
      */
-    insertAt(index, value) {
-        if (index < 0 || index > this.length)
+    addAt(index, value) {
+        if (index < 0 || index > this.size)
             return false;
         if (index === 0) {
             this.unshift(value);
             return true;
         }
-        if (index === this.length) {
+        if (index === this.size) {
             this.push(value);
             return true;
         }
@@ -366,7 +277,7 @@ export class DoublyLinkedList extends IterableElementBase {
         newNode.next = nextNode;
         prevNode.next = newNode;
         nextNode.prev = newNode;
-        this._length++;
+        this._size++;
         return true;
     }
     /**
@@ -377,7 +288,7 @@ export class DoublyLinkedList extends IterableElementBase {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      *
-     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
+     * The `addBefore` function inserts a new value before an existing value or node in a doubly linked list.
      * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
      * before which the new value will be inserted. It can be either the value of the existing node or the existing node
      * itself.
@@ -386,7 +297,7 @@ export class DoublyLinkedList extends IterableElementBase {
      * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
      * insertion fails.
      */
-    insertBefore(existingValueOrNode, newValue) {
+    addBefore(existingValueOrNode, newValue) {
         let existingNode;
         if (existingValueOrNode instanceof DoublyLinkedListNode) {
             existingNode = existingValueOrNode;
@@ -405,7 +316,7 @@ export class DoublyLinkedList extends IterableElementBase {
             if (existingNode === this.head) {
                 this._head = newNode;
             }
-            this._length++;
+            this._size++;
             return true;
         }
         return false;
@@ -418,7 +329,7 @@ export class DoublyLinkedList extends IterableElementBase {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      *
-     * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
+     * The `addAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
      * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
      * after which the new value will be inserted. It can be either the value of the existing node or the existing node
      * itself.
@@ -426,7 +337,7 @@ export class DoublyLinkedList extends IterableElementBase {
      * @returns The method returns a boolean value. It returns true if the insertion is successful, and false if the
      * existing value or node is not found in the doubly linked list.
      */
-    insertAfter(existingValueOrNode, newValue) {
+    addAfter(existingValueOrNode, newValue) {
         let existingNode;
         if (existingValueOrNode instanceof DoublyLinkedListNode) {
             existingNode = existingValueOrNode;
@@ -445,7 +356,7 @@ export class DoublyLinkedList extends IterableElementBase {
             if (existingNode === this.tail) {
                 this._tail = newNode;
             }
-            this._length++;
+            this._size++;
             return true;
         }
         return false;
@@ -465,19 +376,23 @@ export class DoublyLinkedList extends IterableElementBase {
      * bounds.
      */
     deleteAt(index) {
-        if (index < 0 || index >= this.length)
-            return undefined;
-        if (index === 0)
-            return this.shift();
-        if (index === this.length - 1)
-            return this.pop();
+        if (index < 0 || index >= this.size)
+            return false;
+        if (index === 0) {
+            this.shift();
+            return true;
+        }
+        if (index === this.size - 1) {
+            this.pop();
+            return true;
+        }
         const removedNode = this.getNodeAt(index);
         const prevNode = removedNode.prev;
         const nextNode = removedNode.next;
         prevNode.next = nextNode;
         nextNode.prev = prevNode;
-        this._length--;
-        return removedNode.value;
+        this._size--;
+        return true;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -513,26 +428,26 @@ export class DoublyLinkedList extends IterableElementBase {
                 const nextNode = node.next;
                 prevNode.next = nextNode;
                 nextNode.prev = prevNode;
-                this._length--;
+                this._size--;
             }
             return true;
         }
         return false;
     }
     /**
-     * The function checks if a variable has a length greater than zero and returns a boolean value.
+     * The function checks if a variable has a size greater than zero and returns a boolean value.
      * @returns A boolean value is being returned.
      */
     isEmpty() {
-        return this.length === 0;
+        return this.size === 0;
     }
     /**
-     * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
+     * The `clear` function resets the linked list by setting the head, tail, and size to undefined and 0 respectively.
      */
     clear() {
         this._head = undefined;
         this._tail = undefined;
-        this._length = 0;
+        this._size = 0;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -627,6 +542,7 @@ export class DoublyLinkedList extends IterableElementBase {
             [current.prev, current.next] = [current.next, current.prev];
             current = next;
         }
+        return this;
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -730,12 +646,92 @@ export class DoublyLinkedList extends IterableElementBase {
         }
         return mappedList;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The addLast function adds a new node with the given value to the end of the doubly linked list.
+     * @param {E} value - The value to be added to the linked list.
+     */
+    addLast(value) {
+        return this.push(value);
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
+     * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
+     * list is empty, it returns undefined.
+     */
+    pollLast() {
+        return this.pop();
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
+     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
+     * list.
+     */
+    pollFirst() {
+        return this.shift();
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The addFirst function adds a new node with the given value to the beginning of a doubly linked list.
+     * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
+     * doubly linked list.
+     */
+    addFirst(value) {
+        this.unshift(value);
+    }
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      */
-    print() {
-        console.log([...this]);
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * The `get first` function returns the first node in a doubly linked list, or undefined if the list is empty.
+     * @returns The method `get first()` returns the first node of the doubly linked list, or `undefined` if the list is empty.
+     */
+    get first() {
+        return this.head?.value;
+    }
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * The `get last` function returns the last node in a doubly linked list, or undefined if the list is empty.
+     * @returns The method `get last()` returns the last node of the doubly linked list, or `undefined` if the list is empty.
+     */
+    get last() {
+        return this.tail?.value;
     }
     /**
      * The function returns an iterator that iterates over the values of a linked list.

package/dist/mjs/data-structures/linked-list/singly-linked-list.d.ts

@@ -1,5 +1,3 @@
-import { IterableElementBase } from "../base";
-import { ElementCallback } from "../../types";
 /**
  * data-structure-typed
  *
@@ -7,6 +5,8 @@ import { ElementCallback } from "../../types";
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+import type { ElementCallback } from "../../types";
+import { IterableElementBase } from "../base";
 export declare class SinglyLinkedListNode<E = any> {
     value: E;
     next: SinglyLinkedListNode<E> | undefined;
@@ -26,8 +26,8 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
     get head(): SinglyLinkedListNode<E> | undefined;
     protected _tail: SinglyLinkedListNode<E> | undefined;
     get tail(): SinglyLinkedListNode<E> | undefined;
-    protected _length: number;
-    get length(): number;
+    protected _size: number;
+    get size(): number;
     /**
      * Time Complexity: O(n) - Linear time, where n is the length of the input array, as it performs a loop to push each element into the linked list.
      * Space Complexity: O(n) - Linear space, as it creates a new node for each element in the array.
@@ -54,7 +54,7 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * @param {E} value - The "value" parameter represents the value that you want to add to the linked list. It can be of
      * any type (E) as specified in the generic type declaration of the class or function.
      */
-    push(value: E): void;
+    push(value: E): boolean;
     /**
      * Time Complexity: O(1) - Constant time, as it involves basic pointer adjustments.
      * Space Complexity: O(1) - Constant space, as it only creates a new node.
@@ -67,7 +67,7 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * @param {E} value - The "value" parameter represents the value that you want to add to the linked list. It can be of
      * any type (E) as specified in the generic type declaration of the class or function.
      */
-    addLast(value: E): void;
+    addLast(value: E): boolean;
     /**
      * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
      * Space Complexity: O(1) - Constant space.
@@ -132,7 +132,7 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * @param {E} value - The parameter "value" represents the value of the new node that will be added to the beginning of the
      * linked list.
      */
-    unshift(value: E): void;
+    unshift(value: E): boolean;
     /**
      * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
      * Space Complexity: O(1) - Constant space.
@@ -145,7 +145,7 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * @param {E} value - The parameter "value" represents the value of the new node that will be added to the beginning of the
      * linked list.
      */
-    addFirst(value: E): void;
+    addFirst(value: E): boolean;
     /**
      * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
      * Space Complexity: O(1) - Constant space.
@@ -190,7 +190,7 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * @returns The method `deleteAt` returns the value of the node that was deleted, or `undefined` if the index is out of
      * bounds.
      */
-    deleteAt(index: number): E | undefined;
+    deleteAt(index: number): boolean;
     /**
      * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
      * Space Complexity: O(1) - Constant space.
@@ -205,7 +205,7 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * @returns The `delete` method returns a boolean value. It returns `true` if the value or node is found and
      * successfully deleted from the linked list, and `false` if the value or node is not found in the linked list.
      */
-    delete(valueOrNode: E | SinglyLinkedListNode<E> | undefined | undefined): boolean;
+    delete(valueOrNode: E | SinglyLinkedListNode<E> | undefined): boolean;
     /**
      * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
      * Space Complexity: O(1) - Constant space.
@@ -214,7 +214,7 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `insertAt` function inserts a value at a specified index in a singly linked list.
+     * The `addAt` function inserts a value at a specified index in a singly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
      * linked list. It is of type number.
      * @param {E} value - The `value` parameter represents the value that you want to insert into the linked list at the
@@ -222,7 +222,7 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
      * if the index is out of bounds.
      */
-    insertAt(index: number, value: E): boolean;
+    addAt(index: number, value: E): boolean;
     /**
      * The function checks if the length of a data structure is equal to zero and returns a boolean value indicating
      * whether it is empty or not.
@@ -256,7 +256,7 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * The `reverse` function reverses the order of the nodes in a singly linked list.
      * @returns The reverse() method does not return anything. It has a return type of void.
      */
-    reverse(): void;
+    reverse(): this;
     /**
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
      * Space Complexity: O(1) - Constant space.
@@ -309,14 +309,14 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `insertBefore` function inserts a new value before an existing value in a singly linked list.
+     * The `addBefore` function inserts a new value before an existing value in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node that you want to insert the
      * new value before. It can be either the value itself or a node containing the value in the linked list.
      * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the linked list.
-     * @returns The method `insertBefore` returns a boolean value. It returns `true` if the new value was successfully
+     * @returns The method `addBefore` returns a boolean value. It returns `true` if the new value was successfully
      * inserted before the existing value, and `false` otherwise.
      */
-    insertBefore(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
+    addBefore(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
     /**
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
      * Space Complexity: O(1) - Constant space.
@@ -325,14 +325,14 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `insertAfter` function inserts a new node with a given value after an existing node in a singly linked list.
+     * The `addAfter` function inserts a new node with a given value after an existing node in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node in the linked list after which
      * the new value will be inserted. It can be either the value of the existing node or the existing node itself.
      * @param {E} newValue - The value that you want to insert into the linked list after the existing value or node.
      * @returns The method returns a boolean value. It returns true if the new value was successfully inserted after the
      * existing value or node, and false if the existing value or node was not found in the linked list.
      */
-    insertAfter(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
+    addAfter(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
     /**
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
      * Space Complexity: O(1) - Constant space.
@@ -387,10 +387,5 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * of applying the provided `callback` function to each element in the original list.
      */
     map<T>(callback: ElementCallback<E, T>, thisArg?: any): SinglyLinkedList<T>;
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
-     */
-    print(): void;
     protected _getIterator(): IterableIterator<E>;
 }