data-structure-typed 1.49.6 → 1.49.8

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

@@ -56,23 +56,22 @@ export class BSTNode extends BinaryTreeNode {
 export class BST extends BinaryTree {
     /**
      * This is the constructor function for a binary search tree class in TypeScript, which initializes
-     * the tree with optional nodes and options.
-     * @param [nodes] - An optional iterable of KeyOrNodeOrEntry objects that will be added to the
+     * the tree with optional keysOrNodesOrEntries and options.
+     * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects that will be added to the
      * binary search tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary search tree. It can have the following properties:
      */
-    constructor(nodes, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
         if (options) {
             const { variant } = options;
-            if (variant) {
+            if (variant)
                 this._variant = variant;
-            }
         }
         this._root = undefined;
-        if (nodes)
-            this.addMany(nodes);
+        if (keysOrNodesOrEntries)
+            this.addMany(keysOrNodesOrEntries);
     }
     _root;
     get root() {

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

@@ -24,7 +24,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional nodes and options.
-     * @param [nodes] - The `nodes` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
      * objects. It represents the initial nodes that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * nodes to the
@@ -32,7 +32,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
      * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
-    constructor(nodes?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: Partial<RBTreeOptions<K>>);
+    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: RBTreeOptions<K>);
     protected _root: N;
     get root(): N;
     protected _size: number;

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

@@ -26,7 +26,7 @@ export class RedBlackTree extends BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional nodes and options.
-     * @param [nodes] - The `nodes` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
      * objects. It represents the initial nodes that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * nodes to the
@@ -34,11 +34,11 @@ export class RedBlackTree extends BST {
      * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
      * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
-    constructor(nodes, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
         this._root = this.Sentinel;
-        if (nodes)
-            super.addMany(nodes);
+        if (keysOrNodesOrEntries)
+            super.addMany(keysOrNodesOrEntries);
     }
     _root;
     get root() {
@@ -73,7 +73,6 @@ export class RedBlackTree extends BST {
     createTree(options) {
         return new RedBlackTree([], {
             iterationType: this.iterationType,
-            variant: this.variant,
             ...options
         });
     }
@@ -275,9 +274,9 @@ export class RedBlackTree extends BST {
                 this._fixDelete(x);
             }
             this._size--;
+            ans.push({ deleted: z, needBalanced: undefined });
         };
         helper(this.root);
-        // TODO
         return ans;
     }
     /**

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

@@ -27,7 +27,7 @@ export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNo
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>, TREE extends TreeMultimap<K, V, N, TREE> = TreeMultimap<K, V, N, TreeMultimapNested<K, V, N>>> extends AVLTree<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
-    constructor(nodes?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: Partial<TreeMultimapOptions<K>>);
+    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: TreeMultimapOptions<K>);
     private _count;
     get count(): number;
     /**

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

@@ -21,10 +21,10 @@ export class TreeMultimapNode extends AVLTreeNode {
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 export class TreeMultimap extends AVLTree {
-    constructor(nodes, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
-        if (nodes)
-            this.addMany(nodes);
+        if (keysOrNodesOrEntries)
+            this.addMany(keysOrNodesOrEntries);
     }
     _count = 0;
     // TODO the _count is not accurate after nodes count modified

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

@@ -5,13 +5,13 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
+import type { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem, LinkedHashMapOptions } from '../../types';
 import { IterableEntryBase } from '../base';
 /**
  * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key maps to a value.
- * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete elements based on a key.
+ * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete entries based on a key.
  * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
- * 4. Unordered Collection: HashMap does not guarantee the order of elements, and the order may change over time.
+ * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  */
 export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     protected _store: {
@@ -19,16 +19,14 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     };
     protected _objMap: Map<object, V>;
     /**
-     * The constructor function initializes a new instance of a class with optional elements and options.
-     * @param elements - The `elements` parameter is an iterable containing key-value pairs `[K, V]`. It
+     * The constructor function initializes a new instance of a class with optional entries and options.
+     * @param entries - The `entries` parameter is an iterable containing key-value pairs `[K, V]`. It
      * is optional and defaults to an empty array `[]`. This parameter is used to initialize the map with
      * key-value pairs.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the constructor. In this case, it has one property:
      */
-    constructor(elements?: Iterable<[K, V]>, options?: {
-        hashFn: (key: K) => string;
-    });
+    constructor(entries?: Iterable<[K, V]>, options?: HashMapOptions<K>);
     protected _size: number;
     get size(): number;
     isEmpty(): boolean;
@@ -45,10 +43,10 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     set(key: K, value: V): boolean;
     /**
      * The function "setMany" sets multiple key-value pairs in a map.
-     * @param elements - The `elements` parameter is an iterable containing key-value pairs. Each
-     * key-value pair is represented as an array with two elements: the key and the value.
+     * @param entries - The `entries` parameter is an iterable containing key-value pairs. Each
+     * key-value pair is represented as an array with two entries: the key and the value.
      */
-    setMany(elements: Iterable<[K, V]>): boolean[];
+    setMany(entries: Iterable<[K, V]>): boolean[];
     /**
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
      * a string map.
@@ -113,7 +111,6 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
      * from the original `HashMap` that pass the provided `predicate` function.
      */
     filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): HashMap<K, V>;
-    print(): void;
     put(key: K, value: V): boolean;
     /**
      * The function returns an iterator that yields key-value pairs from both an object store and an
@@ -125,8 +122,8 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     protected _getNoObjKey(key: K): string;
 }
 /**
- * 1. Maintaining the Order of Element Insertion: Unlike HashMap, LinkedHashMap maintains the order in which elements are inserted. Therefore, when you traverse it, elements will be returned in the order they were inserted into the map.
- * 2. Based on Hash Table and Linked List: It combines the structures of a hash table and a linked list, using the hash table to ensure fast access, while maintaining the order of elements through the linked list.
+ * 1. Maintaining the Order of Element Insertion: Unlike HashMap, LinkedHashMap maintains the order in which entries are inserted. Therefore, when you traverse it, entries will be returned in the order they were inserted into the map.
+ * 2. Based on Hash Table and Linked List: It combines the structures of a hash table and a linked list, using the hash table to ensure fast access, while maintaining the order of entries through the linked list.
  * 3. Time Complexity: Similar to HashMap, LinkedHashMap offers constant-time performance for get and put operations in most cases.
  */
 export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
@@ -135,9 +132,7 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
     protected _head: HashMapLinkedNode<K, V | undefined>;
     protected _tail: HashMapLinkedNode<K, V | undefined>;
     protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
-    protected _hashFn: (key: K) => string;
-    protected _objHashFn: (key: K) => object;
-    constructor(elements?: Iterable<[K, V]>, options?: HashMapOptions<K>);
+    constructor(entries?: Iterable<[K, V]>, options?: LinkedHashMapOptions<K>);
     protected _size: number;
     get size(): number;
     /**
@@ -242,14 +237,10 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `clear` function clears all the elements in a data structure and resets its properties.
+     * The `clear` function clears all the entries in a data structure and resets its properties.
      */
     clear(): void;
     clone(): LinkedHashMap<K, V>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -266,10 +257,6 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * `LinkedHashMap` object that satisfy the given predicate function.
      */
     filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): LinkedHashMap<K, V>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -288,9 +275,19 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * function.
      */
     map<NV>(callback: EntryCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
     put(key: K, value: V): boolean;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    protected _hashFn: (key: K) => string;
+    protected _objHashFn: (key: K) => object;
+    /**
+     * Time Complexity: O(n), where n is the number of entries in the LinkedHashMap.
      * Space Complexity: O(1)
      *
      * The above function is an iterator that yields key-value pairs from a linked list.

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

@@ -2,22 +2,22 @@ import { IterableEntryBase } from '../base';
 import { isWeakKey, rangeCheck } from '../../utils';
 /**
  * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key maps to a value.
- * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete elements based on a key.
+ * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete entries based on a key.
  * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
- * 4. Unordered Collection: HashMap does not guarantee the order of elements, and the order may change over time.
+ * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  */
 export class HashMap extends IterableEntryBase {
     _store = {};
     _objMap = new Map();
     /**
-     * The constructor function initializes a new instance of a class with optional elements and options.
-     * @param elements - The `elements` parameter is an iterable containing key-value pairs `[K, V]`. It
+     * The constructor function initializes a new instance of a class with optional entries and options.
+     * @param entries - The `entries` parameter is an iterable containing key-value pairs `[K, V]`. It
      * is optional and defaults to an empty array `[]`. This parameter is used to initialize the map with
      * key-value pairs.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the constructor. In this case, it has one property:
      */
-    constructor(elements = [], options) {
+    constructor(entries = [], options) {
         super();
         if (options) {
             const { hashFn } = options;
@@ -25,8 +25,8 @@ export class HashMap extends IterableEntryBase {
                 this._hashFn = hashFn;
             }
         }
-        if (elements) {
-            this.setMany(elements);
+        if (entries) {
+            this.setMany(entries);
         }
     }
     _size = 0;
@@ -68,12 +68,12 @@ export class HashMap extends IterableEntryBase {
     }
     /**
      * The function "setMany" sets multiple key-value pairs in a map.
-     * @param elements - The `elements` parameter is an iterable containing key-value pairs. Each
-     * key-value pair is represented as an array with two elements: the key and the value.
+     * @param entries - The `entries` parameter is an iterable containing key-value pairs. Each
+     * key-value pair is represented as an array with two entries: the key and the value.
      */
-    setMany(elements) {
+    setMany(entries) {
         const results = [];
-        for (const [key, value] of elements)
+        for (const [key, value] of entries)
             results.push(this.set(key, value));
         return results;
     }
@@ -189,9 +189,6 @@ export class HashMap extends IterableEntryBase {
         }
         return filteredMap;
     }
-    print() {
-        console.log([...this.entries()]);
-    }
     put(key, value) {
         return this.set(key, value);
     }
@@ -231,8 +228,8 @@ export class HashMap extends IterableEntryBase {
     }
 }
 /**
- * 1. Maintaining the Order of Element Insertion: Unlike HashMap, LinkedHashMap maintains the order in which elements are inserted. Therefore, when you traverse it, elements will be returned in the order they were inserted into the map.
- * 2. Based on Hash Table and Linked List: It combines the structures of a hash table and a linked list, using the hash table to ensure fast access, while maintaining the order of elements through the linked list.
+ * 1. Maintaining the Order of Element Insertion: Unlike HashMap, LinkedHashMap maintains the order in which entries are inserted. Therefore, when you traverse it, entries will be returned in the order they were inserted into the map.
+ * 2. Based on Hash Table and Linked List: It combines the structures of a hash table and a linked list, using the hash table to ensure fast access, while maintaining the order of entries through the linked list.
  * 3. Time Complexity: Similar to HashMap, LinkedHashMap offers constant-time performance for get and put operations in most cases.
  */
 export class LinkedHashMap extends IterableEntryBase {
@@ -241,20 +238,19 @@ export class LinkedHashMap extends IterableEntryBase {
     _head;
     _tail;
     _sentinel;
-    _hashFn;
-    _objHashFn;
-    constructor(elements, options = {
-        hashFn: (key) => String(key),
-        objHashFn: (key) => key
-    }) {
+    constructor(entries, options) {
         super();
         this._sentinel = {};
         this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
-        const { hashFn, objHashFn } = options;
-        this._hashFn = hashFn;
-        this._objHashFn = objHashFn;
-        if (elements) {
-            for (const el of elements) {
+        if (options) {
+            const { hashFn, objHashFn } = options;
+            if (hashFn)
+                this._hashFn = hashFn;
+            if (objHashFn)
+                this._objHashFn = objHashFn;
+        }
+        if (entries) {
+            for (const el of entries) {
                 this.set(el[0], el[1]);
             }
         }
@@ -495,7 +491,7 @@ export class LinkedHashMap extends IterableEntryBase {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `clear` function clears all the elements in a data structure and resets its properties.
+     * The `clear` function clears all the entries in a data structure and resets its properties.
      */
     clear() {
         this._noObjMap = {};
@@ -510,10 +506,6 @@ export class LinkedHashMap extends IterableEntryBase {
         }
         return cloned;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -540,10 +532,6 @@ export class LinkedHashMap extends IterableEntryBase {
         }
         return filteredMap;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -571,11 +559,21 @@ export class LinkedHashMap extends IterableEntryBase {
         }
         return mappedMap;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
     put(key, value) {
         return this.set(key, value);
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    _hashFn = (key) => String(key);
+    _objHashFn = (key) => key;
+    /**
+     * Time Complexity: O(n), where n is the number of entries in the LinkedHashMap.
      * Space Complexity: O(1)
      *
      * The above function is an iterator that yields key-value pairs from a linked list.

package/dist/mjs/data-structures/hash/index.d.ts

@@ -1,2 +1 @@
-export * from './hash-table';
 export * from './hash-map';

package/dist/mjs/data-structures/hash/index.js

@@ -1,2 +1 @@
-export * from './hash-table';
 export * from './hash-map';

package/dist/mjs/data-structures/heap/heap.d.ts

@@ -19,8 +19,9 @@ import { IterableElementBase } from '../base';
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  */
 export declare class Heap<E = any> extends IterableElementBase<E> {
-    options: HeapOptions<E>;
     constructor(elements?: Iterable<E>, options?: HeapOptions<E>);
+    protected _comparator: (a: E, b: E) => number;
+    get comparator(): (a: E, b: E) => number;
     protected _elements: E[];
     get elements(): E[];
     /**

package/dist/mjs/data-structures/heap/heap.js

@@ -18,24 +18,12 @@ import { IterableElementBase } from '../base';
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  */
 export class Heap extends IterableElementBase {
-    options;
-    constructor(elements, options) {
+    constructor(elements = [], options) {
         super();
-        const defaultComparator = (a, b) => {
-            if (!(typeof a === 'number' && typeof b === 'number')) {
-                throw new Error('The a, b params of compare function must be number');
-            }
-            else {
-                return a - b;
-            }
-        };
         if (options) {
-            this.options = options;
-        }
-        else {
-            this.options = {
-                comparator: defaultComparator
-            };
+            const { comparator } = options;
+            if (comparator)
+                this._comparator = comparator;
         }
         if (elements) {
             for (const el of elements) {
@@ -44,6 +32,17 @@ export class Heap extends IterableElementBase {
             // this.fix();
         }
     }
+    _comparator = (a, b) => {
+        if (!(typeof a === 'number' && typeof b === 'number')) {
+            throw new Error('The a, b params of compare function must be number');
+        }
+        else {
+            return a - b;
+        }
+    };
+    get comparator() {
+        return this._comparator;
+    }
     _elements = [];
     get elements() {
         return this._elements;
@@ -253,7 +252,7 @@ export class Heap extends IterableElementBase {
      * @returns A new Heap instance containing the same elements.
      */
     clone() {
-        const clonedHeap = new Heap([], this.options);
+        const clonedHeap = new Heap([], { comparator: this.comparator });
         clonedHeap._elements = [...this.elements];
         return clonedHeap;
     }
@@ -379,7 +378,7 @@ export class Heap extends IterableElementBase {
         while (index > 0) {
             const parent = (index - 1) >> 1;
             const parentItem = this.elements[parent];
-            if (this.options.comparator(parentItem, element) <= 0)
+            if (this.comparator(parentItem, element) <= 0)
                 break;
             this.elements[index] = parentItem;
             index = parent;
@@ -401,11 +400,11 @@ export class Heap extends IterableElementBase {
             let left = (index << 1) | 1;
             const right = left + 1;
             let minItem = this.elements[left];
-            if (right < this.elements.length && this.options.comparator(minItem, this.elements[right]) > 0) {
+            if (right < this.elements.length && this.comparator(minItem, this.elements[right]) > 0) {
                 left = right;
                 minItem = this.elements[right];
             }
-            if (this.options.comparator(minItem, element) >= 0)
+            if (this.comparator(minItem, element) >= 0)
                 break;
             this.elements[index] = minItem;
             index = left;

package/dist/mjs/data-structures/heap/max-heap.js

@@ -10,7 +10,7 @@ import { Heap } from './heap';
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  */
 export class MaxHeap extends Heap {
-    constructor(elements, options = {
+    constructor(elements = [], options = {
         comparator: (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
                 throw new Error('The a, b params of compare function must be number');

package/dist/mjs/data-structures/heap/min-heap.js

@@ -10,7 +10,7 @@ import { Heap } from './heap';
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  */
 export class MinHeap extends Heap {
-    constructor(elements, options = {
+    constructor(elements = [], options = {
         comparator: (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
                 throw new Error('The a, b params of compare function must be number');

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

@@ -24,7 +24,7 @@ export class DoublyLinkedList extends IterableElementBase {
     /**
      * The constructor initializes the linked list with an empty head, tail, and size.
      */
-    constructor(elements) {
+    constructor(elements = []) {
         super();
         this._head = undefined;
         this._tail = undefined;

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

@@ -16,11 +16,8 @@ export class SinglyLinkedList extends IterableElementBase {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor(elements) {
+    constructor(elements = []) {
         super();
-        this._head = undefined;
-        this._tail = undefined;
-        this._size = 0;
         if (elements) {
             for (const el of elements)
                 this.push(el);
@@ -34,7 +31,7 @@ export class SinglyLinkedList extends IterableElementBase {
     get tail() {
         return this._tail;
     }
-    _size;
+    _size = 0;
     get size() {
         return this._size;
     }

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

@@ -5,6 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+import type { SkipLinkedListOptions } from '../../types';
 export declare class SkipListNode<K, V> {
     key: K;
     value: V;
@@ -12,14 +13,7 @@ export declare class SkipListNode<K, V> {
     constructor(key: K, value: V, level: number);
 }
 export declare class SkipList<K, V> {
-    /**
-     * The constructor initializes a SkipList with a specified maximum level and probability.
-     * @param [maxLevel=16] - The `maxLevel` parameter represents the maximum level that a skip list can have. It determines
-     * the maximum number of levels that can be created in the skip list.
-     * @param [probability=0.5] - The probability parameter represents the probability of a node being promoted to a higher
-     * level in the skip list. It is used to determine the height of each node in the skip list.
-     */
-    constructor(maxLevel?: number, probability?: number);
+    constructor(elements?: Iterable<[K, V]>, options?: SkipLinkedListOptions);
     protected _head: SkipListNode<K, V>;
     get head(): SkipListNode<K, V>;
     protected _level: number;

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

@@ -1,10 +1,3 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
 export class SkipListNode {
     key;
     value;
@@ -16,32 +9,32 @@ export class SkipListNode {
     }
 }
 export class SkipList {
-    /**
-     * The constructor initializes a SkipList with a specified maximum level and probability.
-     * @param [maxLevel=16] - The `maxLevel` parameter represents the maximum level that a skip list can have. It determines
-     * the maximum number of levels that can be created in the skip list.
-     * @param [probability=0.5] - The probability parameter represents the probability of a node being promoted to a higher
-     * level in the skip list. It is used to determine the height of each node in the skip list.
-     */
-    constructor(maxLevel = 16, probability = 0.5) {
-        this._head = new SkipListNode(undefined, undefined, maxLevel);
-        this._level = 0;
-        this._maxLevel = maxLevel;
-        this._probability = probability;
+    constructor(elements = [], options) {
+        if (options) {
+            const { maxLevel, probability } = options;
+            if (typeof maxLevel === 'number')
+                this._maxLevel = maxLevel;
+            if (typeof probability === 'number')
+                this._probability = probability;
+        }
+        if (elements) {
+            for (const [key, value] of elements)
+                this.add(key, value);
+        }
     }
-    _head;
+    _head = new SkipListNode(undefined, undefined, this.maxLevel);
     get head() {
         return this._head;
     }
-    _level;
+    _level = 0;
     get level() {
         return this._level;
     }
-    _maxLevel;
+    _maxLevel = 16;
     get maxLevel() {
         return this._maxLevel;
     }
-    _probability;
+    _probability = 0.5;
     get probability() {
         return this._probability;
     }