data-structure-typed 0.8.18 → 1.12.9

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

@@ -1,40 +1,40 @@
 "use strict";
-// 操作      常见名称       Ada           Java        JavaScript     C++          Python      Perl       PHP             Ruby
-// 尾部插入   inject, snoc Append         offerLast   push          push_back    append      push        array_push      push
-// 头部插入   push, cons   Prepend        offerFirst  unshift       push_front   appendleft  unshift     array_unshift   unshift
-// 尾部删除   eject        Delete_Last    pollLast    pop           pop_back     pop         pop         array_pop       pop
-// 头部删除   pop          Delete_First   pollFirst   shift         pop_front    popleft     shift       array_shift     shift
-// 查看尾部                Last_Element   peekLast    [length - 1]  back         [-1]        $array[-1]  end             last
-// 查看头部                First_Element  peekFirst   [0]           front        [0]         $array[0]   reset           first
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DoublyLinkedList = exports.DoublyLinkedListNode = void 0;
-class DoublyLinkedListNode {
-    constructor(nodeValue) {
+var DoublyLinkedListNode = /** @class */ (function () {
+    function DoublyLinkedListNode(nodeValue) {
         this.val = nodeValue;
         this.next = null;
         this.prev = null;
     }
-}
+    return DoublyLinkedListNode;
+}());
 exports.DoublyLinkedListNode = DoublyLinkedListNode;
-class DoublyLinkedList {
-    constructor() {
+var DoublyLinkedList = /** @class */ (function () {
+    function DoublyLinkedList() {
         this._first = null;
         this._last = null;
         this._size = 0;
         // --- end extra methods ---
     }
-    get size() {
-        return this._size;
-    }
-    set size(v) {
-        this._size = v;
-    }
+    Object.defineProperty(DoublyLinkedList.prototype, "size", {
+        get: function () {
+            return this._size;
+        },
+        set: function (v) {
+            this._size = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
-     * Adds a node at the beginning of the linked list
-     * @param val Value to be stored at the beginning of the linked list
+     * The function adds a new node with a given value to the beginning of a doubly linked list.
+     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the beginning of
+     * the doubly linked list.
+     * @returns A boolean value is being returned.
      */
-    offerFirst(val) {
-        const newNode = new DoublyLinkedListNode(val);
+    DoublyLinkedList.prototype.offerFirst = function (val) {
+        var newNode = new DoublyLinkedListNode(val);
         if (this._size === 0) {
             this._first = newNode;
             this._last = newNode;
@@ -47,13 +47,15 @@ class DoublyLinkedList {
         }
         this._size++;
         return true;
-    }
+    };
     /**
-     * Adds a node to the end of the linked list
-     * @param val Value to be stored in the Doubly linked list node
+     * The function adds a new node with a given value to the end of a doubly linked list.
+     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the end of the
+     * doubly linked list.
+     * @returns a boolean value, which is always true.
      */
-    offerLast(val) {
-        const newNode = new DoublyLinkedListNode(val);
+    DoublyLinkedList.prototype.offerLast = function (val) {
+        var newNode = new DoublyLinkedListNode(val);
         if (this._size === 0) {
             this._first = newNode;
             this._last = newNode;
@@ -66,8 +68,16 @@ class DoublyLinkedList {
         }
         this._size++;
         return true;
-    }
-    peekFirst(by) {
+    };
+    /**
+     * The `peekFirst` function returns the first node or value in a doubly linked list, depending on the specified
+     * parameter.
+     * @param {DoublyLinkedListGetBy} [by] - The "by" parameter is an optional parameter of type DoublyLinkedListGetBy. It
+     * is used to specify whether to return the first node, the value of the first node, or the first node itself.
+     * @returns The method `peekFirst` returns either the first node of the doubly linked list (`DoublyLinkedListNode<T>`),
+     * the value of the first node (`T`), or `null` depending on the value of the `by` parameter.
+     */
+    DoublyLinkedList.prototype.peekFirst = function (by) {
         var _a, _b, _c, _d, _e;
         switch (by) {
             case 'node':
@@ -77,9 +87,17 @@ class DoublyLinkedList {
             default:
                 return (_e = (_d = this._first) === null || _d === void 0 ? void 0 : _d.val) !== null && _e !== void 0 ? _e : null;
         }
-    }
-    peekLast(by = 'val') {
+    };
+    /**
+     * The `peekLast` function returns the last node or value in a doubly linked list.
+     * @param {DoublyLinkedListGetBy} [by=val] - The "by" parameter is an optional parameter of type DoublyLinkedListGetBy.
+     * It specifies whether to return the last node, the value of the last node, or both. The default value is 'val', which
+     * means that if no value is provided for the "by" parameter, the method
+     * @returns The method `peekLast` returns the last node, value, or null based on the specified `by` parameter.
+     */
+    DoublyLinkedList.prototype.peekLast = function (by) {
         var _a, _b, _c, _d, _e;
+        if (by === void 0) { by = 'val'; }
         switch (by) {
             case 'node':
                 return (_a = this._last) !== null && _a !== void 0 ? _a : null;
@@ -88,15 +106,23 @@ class DoublyLinkedList {
             default:
                 return (_e = (_d = this._last) === null || _d === void 0 ? void 0 : _d.val) !== null && _e !== void 0 ? _e : null;
         }
-    }
+    };
     /**
-     * Removes a node form the beginning of the linked list and will return the node val
+     * The function `pollFirst` removes and returns the first element of a doubly linked list, either as a node or its
+     * value, depending on the specified parameter.
+     * @param {DoublyLinkedListGetBy} [by=val] - The "by" parameter is an optional parameter of type DoublyLinkedListGetBy.
+     * It specifies the criteria by which the first element should be retrieved from the doubly linked list. The default
+     * value is 'val', which means the first element will be retrieved by its value. Other possible values for "by
+     * @returns The method `pollFirst` returns either the value of the first node in the doubly linked list, the first node
+     * itself, or null if the list is empty. The specific return type depends on the value of the `by` parameter. If `by`
+     * is set to 'node', the method returns the first node. If `by` is set to 'val', the method returns the value
      */
-    pollFirst(by = 'val') {
+    DoublyLinkedList.prototype.pollFirst = function (by) {
         var _a, _b, _c;
+        if (by === void 0) { by = 'val'; }
         if (this._size === 0)
             return null;
-        const oldHead = this._first;
+        var oldHead = this._first;
         if (this._size === 1) {
             this._first = null;
             this._last = null;
@@ -117,15 +143,23 @@ class DoublyLinkedList {
             default:
                 return (_c = oldHead === null || oldHead === void 0 ? void 0 : oldHead.val) !== null && _c !== void 0 ? _c : null;
         }
-    }
+    };
     /**
-     * Removes a node at the end of the linked list and will return the node value
+     * The function `pollLast` removes and returns the last element in a doubly linked list, either as a node or its value,
+     * depending on the specified parameter.
+     * @param {DoublyLinkedListGetBy} [by=val] - The parameter "by" is of type DoublyLinkedListGetBy, which is an enum that
+     * can have two possible values: 'node' or 'val'. It determines the type of value that will be returned by the pollLast
+     * method. If 'node' is specified, the method will return the
+     * @returns The method `pollLast` returns either a `DoublyLinkedListNode<T>`, the value of the node (`T`), or `null`.
+     * The specific type that is returned depends on the value of the `by` parameter. If `by` is set to `'node'`, then a
+     * `DoublyLinkedListNode<T>` is returned. If `by` is set to `'
      */
-    pollLast(by = 'val') {
+    DoublyLinkedList.prototype.pollLast = function (by) {
         var _a, _b, _c;
+        if (by === void 0) { by = 'val'; }
         if (this._size === 0)
             return null;
-        const polled = this._last;
+        var polled = this._last;
         if (this._size === 1) {
             this._first = null;
             this._last = null;
@@ -146,7 +180,7 @@ class DoublyLinkedList {
             default:
                 return (_c = polled === null || polled === void 0 ? void 0 : polled.val) !== null && _c !== void 0 ? _c : null;
         }
-    }
+    };
     /**
      * Returns the node at the specified index of the linked list.
      * If index = 0; first element in the list is returned.
@@ -154,11 +188,12 @@ class DoublyLinkedList {
      * @param index Index of the node to be retrieved
      * @param by Return value type
      */
-    get(index, by = 'val') {
+    DoublyLinkedList.prototype.get = function (index, by) {
         var _a, _b;
+        if (by === void 0) { by = 'val'; }
         if (index < 0 || index >= this._size)
             return null;
-        let count, current;
+        var count, current;
         if (index <= this._size / 2) {
             count = 0;
             current = this._first;
@@ -183,7 +218,7 @@ class DoublyLinkedList {
             default:
                 return (_b = current === null || current === void 0 ? void 0 : current.val) !== null && _b !== void 0 ? _b : null;
         }
-    }
+    };
     /**
      * Updates the value of the node at the specified index.
      * If index = 0; Value of the first element in the list is updated.
@@ -191,33 +226,33 @@ class DoublyLinkedList {
      * @param index Index of the node to be updated
      * @param val New value of the node
      */
-    set(index, val) {
-        const foundNode = this.get(index, 'node');
+    DoublyLinkedList.prototype.set = function (index, val) {
+        var foundNode = this.get(index, 'node');
         if (foundNode !== null) {
             foundNode.val = val;
             return true;
         }
         return false;
-    }
-    isEmpty() {
+    };
+    DoublyLinkedList.prototype.isEmpty = function () {
         return this._size === 0;
-    }
+    };
     // --- start extra methods ---
     /**
      * Inserts a new node at the specified index.
      * @param index Index at which the new node has to be inserted
      * @param val Value of the new node to be inserted
      */
-    insert(index, val) {
+    DoublyLinkedList.prototype.insert = function (index, val) {
         if (index < 0 || index > this._size)
             return false;
         if (index === 0)
             return !!this.offerFirst(val);
         if (index === this._size)
             return !!this.offerLast(val);
-        const newNode = new DoublyLinkedListNode(val);
-        const prevNode = this.get(index - 1, 'node');
-        const nextNode = prevNode === null || prevNode === void 0 ? void 0 : prevNode.next;
+        var newNode = new DoublyLinkedListNode(val);
+        var prevNode = this.get(index - 1, 'node');
+        var nextNode = prevNode === null || prevNode === void 0 ? void 0 : prevNode.next;
         if (prevNode)
             prevNode.next = newNode;
         newNode.prev = prevNode;
@@ -226,12 +261,16 @@ class DoublyLinkedList {
             nextNode.prev = newNode;
         this._size++;
         return true;
-    }
+    };
     /**
-     * Removes a node at the specified index and returns its value.
-     * @param index Index at which the node has to be removed.
+     * The `remove` function removes an element at a specified index from a data structure, updating the links between
+     * nodes accordingly.
+     * @param {number} index - The index parameter represents the position of the element to be removed in the data
+     * structure. It is of type number.
+     * @returns The `remove` method returns the value of the removed element (`T`) if the removal is successful, or `null`
+     * if the index is out of bounds.
      */
-    remove(index) {
+    DoublyLinkedList.prototype.remove = function (index) {
         var _a, _b, _c;
         if (index < 0 || index > this._size - 1)
             return null;
@@ -240,9 +279,9 @@ class DoublyLinkedList {
         else if (index === this._size - 1)
             return (_b = (_a = this.pollLast('node')) === null || _a === void 0 ? void 0 : _a.val) !== null && _b !== void 0 ? _b : null;
         else {
-            const prevNode = this.get(index - 1, 'node');
-            const removeNode = prevNode === null || prevNode === void 0 ? void 0 : prevNode.next;
-            const nextNode = removeNode === null || removeNode === void 0 ? void 0 : removeNode.next;
+            var prevNode = this.get(index - 1, 'node');
+            var removeNode = prevNode === null || prevNode === void 0 ? void 0 : prevNode.next;
+            var nextNode = removeNode === null || removeNode === void 0 ? void 0 : removeNode.next;
             if (prevNode)
                 prevNode.next = nextNode !== null && nextNode !== void 0 ? nextNode : null;
             if (nextNode)
@@ -254,6 +293,7 @@ class DoublyLinkedList {
             this._size--;
             return (_c = removeNode === null || removeNode === void 0 ? void 0 : removeNode.val) !== null && _c !== void 0 ? _c : null;
         }
-    }
-}
+    };
+    return DoublyLinkedList;
+}());
 exports.DoublyLinkedList = DoublyLinkedList;

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

@@ -1,7 +1,7 @@
-/** Type used for filter and find methods, returning a boolean */
-type TTestFunction<NodeData> = (data: NodeData, index: number, list: SinglyLinkedList<NodeData>) => boolean;
-/** Type used for map and forEach methods, returning anything */
-type TMapFunction<NodeData> = (data: any, index: number, list: SinglyLinkedList<NodeData>) => any;
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 /**
  * The class which represents one link or node in a linked list
  * ```ts
@@ -72,6 +72,13 @@ export declare class SinglyLinkedListNode<NodeData = any> {
  * ```
  */
 export declare class SinglyLinkedList<NodeData = any> {
+    /** The head of the list, the first node */
+    head: SinglyLinkedListNode<NodeData> | null;
+    /** The tail of the list, the last node */
+    tail: SinglyLinkedListNode<NodeData> | null;
+    /** Internal size reference */
+    private size;
+    constructor(...args: NodeData[]);
     /**
      * The length of the list
      */
@@ -85,13 +92,6 @@ export declare class SinglyLinkedList<NodeData = any> {
      * @param iterable Any iterable datatype like Array or Map
      */
     static from<T>(iterable: Iterable<T>): SinglyLinkedList<T>;
-    /** The head of the list, the first node */
-    head: SinglyLinkedListNode<NodeData> | null;
-    /** The tail of the list, the last node */
-    tail: SinglyLinkedListNode<NodeData> | null;
-    /** Internal size reference */
-    private size;
-    constructor(...args: NodeData[]);
     /**
      * Get the node val at a specified index, zero based
      * ```ts
@@ -117,7 +117,7 @@ export declare class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f A function to be applied to the val of each node
      */
-    findNodeIndex(f: TTestFunction<NodeData>): ({
+    findNodeIndex(f: (data: NodeData, index: number, list: SinglyLinkedList<NodeData>) => boolean): ({
         node: SinglyLinkedListNode<NodeData>;
         index: number;
     }) | undefined;
@@ -130,7 +130,7 @@ export declare class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f Function to test val against
      */
-    findNode(f: TTestFunction<NodeData>): SinglyLinkedListNode<NodeData> | undefined;
+    findNode(f: (data: NodeData, index: number, list: SinglyLinkedList<NodeData>) => boolean): SinglyLinkedListNode<NodeData> | undefined;
     /**
      * Returns the value of the first element in the list that
      * satisfies the provided testing function. Otherwise undefined is returned.
@@ -139,7 +139,7 @@ export declare class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f Function to test val against
      */
-    find(f: TTestFunction<NodeData>): NodeData | undefined;
+    find(f: (data: NodeData, index: number, list: SinglyLinkedList<NodeData>) => boolean): NodeData | undefined;
     /**
      * Returns the index of the first node in the list that
      * satisfies the provided testing function. Ohterwise -1 is returned.
@@ -148,7 +148,7 @@ export declare class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f Function to test val against
      */
-    findIndex(f: TTestFunction<NodeData>): number;
+    findIndex(f: (data: NodeData, index: number, list: SinglyLinkedList<NodeData>) => boolean): number;
     /**
      * Append one or any number of nodes to the end of the list.
      * This modifies the list in place and returns the list itself
@@ -298,7 +298,7 @@ export declare class SinglyLinkedList<NodeData = any> {
      * @param f Function to execute for each element, taking up to three arguments.
      * @param reverse Indicates if the list should be walked in reverse order, default is false
      */
-    forEach(f: TMapFunction<NodeData>, reverse?: boolean): void;
+    forEach(f: (data: any, index: number, list: SinglyLinkedList<NodeData>) => any, reverse?: boolean): void;
     /**
      * The map() method creates a new list with the results of
      * calling a provided function on every node in the calling list.
@@ -308,7 +308,7 @@ export declare class SinglyLinkedList<NodeData = any> {
      * @param f Function that produces an node of the new list, taking up to three arguments
      * @param reverse Indicates if the list should be mapped in reverse order, default is false
      */
-    map(f: TMapFunction<NodeData>, reverse?: boolean): SinglyLinkedList<NodeData | {}>;
+    map(f: (data: any, index: number, list: SinglyLinkedList<NodeData>) => any, reverse?: boolean): SinglyLinkedList<NodeData | {}>;
     /**
      * The filter() method creates a new list with all nodes
      * that pass the test implemented by the provided function.
@@ -318,7 +318,7 @@ export declare class SinglyLinkedList<NodeData = any> {
      * @param f Function to test each node val in the list. Return true to keep the node
      * @param reverse Indicates if the list should be filtered in reverse order, default is false
      */
-    filter(f: TTestFunction<NodeData>, reverse?: boolean): SinglyLinkedList<NodeData | {}>;
+    filter(f: (data: NodeData, index: number, list: SinglyLinkedList<NodeData>) => boolean, reverse?: boolean): SinglyLinkedList<NodeData | {}>;
     /**
      * Reduce over each node in the list
      * ```ts
@@ -355,4 +355,3 @@ export declare class SinglyLinkedList<NodeData = any> {
     /** Private helper function to reduce duplication of pop() and shift() methods */
     private removeFromAnyEnd;
 }
-export {};