min-heap-typed 1.39.6 → 1.40.0

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

@@ -15,27 +15,9 @@ class DoublyLinkedListNode {
      * is defined as a generic type "E".
      */
     constructor(value) {
-        this._value = value;
-        this._next = null;
-        this._prev = null;
-    }
-    get value() {
-        return this._value;
-    }
-    set value(value) {
-        this._value = value;
-    }
-    get next() {
-        return this._next;
-    }
-    set next(value) {
-        this._next = value;
-    }
-    get prev() {
-        return this._prev;
-    }
-    set prev(value) {
-        this._prev = value;
+        this.value = value;
+        this.next = null;
+        this.prev = null;
     }
 }
 exports.DoublyLinkedListNode = DoublyLinkedListNode;
@@ -51,15 +33,9 @@ class DoublyLinkedList {
     get head() {
         return this._head;
     }
-    set head(value) {
-        this._head = value;
-    }
     get tail() {
         return this._tail;
     }
-    set tail(value) {
-        this._tail = value;
-    }
     get length() {
         return this._length;
     }
@@ -86,13 +62,13 @@ class DoublyLinkedList {
     push(value) {
         const newNode = new DoublyLinkedListNode(value);
         if (!this.head) {
-            this.head = newNode;
-            this.tail = newNode;
+            this._head = newNode;
+            this._tail = newNode;
         }
         else {
             newNode.prev = this.tail;
             this.tail.next = newNode;
-            this.tail = newNode;
+            this._tail = newNode;
         }
         this._length++;
     }
@@ -113,11 +89,11 @@ class DoublyLinkedList {
             return undefined;
         const removedNode = this.tail;
         if (this.head === this.tail) {
-            this.head = null;
-            this.tail = null;
+            this._head = null;
+            this._tail = null;
         }
         else {
-            this.tail = removedNode.prev;
+            this._tail = removedNode.prev;
             this.tail.next = null;
         }
         this._length--;
@@ -141,11 +117,11 @@ class DoublyLinkedList {
             return undefined;
         const removedNode = this.head;
         if (this.head === this.tail) {
-            this.head = null;
-            this.tail = null;
+            this._head = null;
+            this._tail = null;
         }
         else {
-            this.head = removedNode.next;
+            this._head = removedNode.next;
             this.head.prev = null;
         }
         this._length--;
@@ -167,13 +143,13 @@ class DoublyLinkedList {
     unshift(value) {
         const newNode = new DoublyLinkedListNode(value);
         if (!this.head) {
-            this.head = newNode;
-            this.tail = newNode;
+            this._head = newNode;
+            this._tail = newNode;
         }
         else {
             newNode.next = this.head;
             this.head.prev = newNode;
-            this.head = newNode;
+            this._head = newNode;
         }
         this._length++;
     }
@@ -308,7 +284,7 @@ class DoublyLinkedList {
             newNode.next = existingNode;
             existingNode.prev = newNode;
             if (existingNode === this.head) {
-                this.head = newNode;
+                this._head = newNode;
             }
             this._length++;
             return true;
@@ -470,7 +446,7 @@ class DoublyLinkedList {
      */
     reverse() {
         let current = this.head;
-        [this.head, this.tail] = [this.tail, this.head];
+        [this._head, this._tail] = [this.tail, this.head];
         while (current) {
             const next = current.next;
             [current.prev, current.next] = [current.next, current.prev];
@@ -572,7 +548,7 @@ class DoublyLinkedList {
             newNode.prev = existingNode;
             existingNode.next = newNode;
             if (existingNode === this.tail) {
-                this.tail = newNode;
+                this._tail = newNode;
             }
             this._length++;
             return true;

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

@@ -6,31 +6,25 @@
  * @license MIT License
  */
 export declare class SinglyLinkedListNode<E = any> {
+    value: E;
+    next: SinglyLinkedListNode<E> | null;
     /**
      * The constructor function initializes an instance of a class with a given value and sets the next property to null.
      * @param {E} value - The "value" parameter is of type E, which means it can be any data type. It represents the value that
      * will be stored in the node of a linked list.
      */
     constructor(value: E);
-    private _value;
-    get value(): E;
-    set value(value: E);
-    private _next;
-    get next(): SinglyLinkedListNode<E> | null;
-    set next(value: SinglyLinkedListNode<E> | null);
 }
 export declare class SinglyLinkedList<E = any> {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
     constructor();
-    private _head;
+    protected _head: SinglyLinkedListNode<E> | null;
     get head(): SinglyLinkedListNode<E> | null;
-    set head(value: SinglyLinkedListNode<E> | null);
-    private _tail;
+    protected _tail: SinglyLinkedListNode<E> | null;
     get tail(): SinglyLinkedListNode<E> | null;
-    set tail(value: SinglyLinkedListNode<E> | null);
-    private _length;
+    protected _length: number;
     get length(): number;
     /**
      * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given

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

@@ -15,20 +15,8 @@ class SinglyLinkedListNode {
      * will be stored in the node of a linked list.
      */
     constructor(value) {
-        this._value = value;
-        this._next = null;
-    }
-    get value() {
-        return this._value;
-    }
-    set value(value) {
-        this._value = value;
-    }
-    get next() {
-        return this._next;
-    }
-    set next(value) {
-        this._next = value;
+        this.value = value;
+        this.next = null;
     }
 }
 exports.SinglyLinkedListNode = SinglyLinkedListNode;
@@ -44,15 +32,9 @@ class SinglyLinkedList {
     get head() {
         return this._head;
     }
-    set head(value) {
-        this._head = value;
-    }
     get tail() {
         return this._tail;
     }
-    set tail(value) {
-        this._tail = value;
-    }
     get length() {
         return this._length;
     }
@@ -77,12 +59,12 @@ class SinglyLinkedList {
     push(value) {
         const newNode = new SinglyLinkedListNode(value);
         if (!this.head) {
-            this.head = newNode;
-            this.tail = newNode;
+            this._head = newNode;
+            this._tail = newNode;
         }
         else {
             this.tail.next = newNode;
-            this.tail = newNode;
+            this._tail = newNode;
         }
         this._length++;
     }
@@ -105,8 +87,8 @@ class SinglyLinkedList {
             return undefined;
         if (this.head === this.tail) {
             const value = this.head.value;
-            this.head = null;
-            this.tail = null;
+            this._head = null;
+            this._tail = null;
             this._length--;
             return value;
         }
@@ -116,7 +98,7 @@ class SinglyLinkedList {
         }
         const value = this.tail.value;
         current.next = null;
-        this.tail = current;
+        this._tail = current;
         this._length--;
         return value;
     }
@@ -137,7 +119,7 @@ class SinglyLinkedList {
         if (!this.head)
             return undefined;
         const removedNode = this.head;
-        this.head = this.head.next;
+        this._head = this.head.next;
         this._length--;
         return removedNode.value;
     }
@@ -156,12 +138,12 @@ class SinglyLinkedList {
     unshift(value) {
         const newNode = new SinglyLinkedListNode(value);
         if (!this.head) {
-            this.head = newNode;
-            this.tail = newNode;
+            this._head = newNode;
+            this._tail = newNode;
         }
         else {
             newNode.next = this.head;
-            this.head = newNode;
+            this._head = newNode;
         }
         this._length++;
     }
@@ -244,15 +226,15 @@ class SinglyLinkedList {
         while (current) {
             if (current.value === value) {
                 if (prev === null) {
-                    this.head = current.next;
+                    this._head = current.next;
                     if (current === this.tail) {
-                        this.tail = null;
+                        this._tail = null;
                     }
                 }
                 else {
                     prev.next = current.next;
                     if (current === this.tail) {
-                        this.tail = prev;
+                        this._tail = prev;
                     }
                 }
                 this._length--;
@@ -335,7 +317,7 @@ class SinglyLinkedList {
             prev = current;
             current = next;
         }
-        [this.head, this.tail] = [this.tail, this.head];
+        [this._head, this._tail] = [this.tail, this.head];
     }
     /**
      * The `find` function iterates through a linked list and returns the first element that satisfies a given condition.
@@ -445,7 +427,7 @@ class SinglyLinkedList {
             newNode.next = existingNode.next;
             existingNode.next = newNode;
             if (existingNode === this.tail) {
-                this.tail = newNode;
+                this._tail = newNode;
             }
             this._length++;
             return true;

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

@@ -20,18 +20,14 @@ export declare class SkipList<K, V> {
      * level in the skip list. It is used to determine the height of each node in the skip list.
      */
     constructor(maxLevel?: number, probability?: number);
-    private _head;
+    protected _head: SkipListNode<K, V>;
     get head(): SkipListNode<K, V>;
-    set head(value: SkipListNode<K, V>);
-    private _level;
+    protected _level: number;
     get level(): number;
-    set level(value: number);
-    private _maxLevel;
+    protected _maxLevel: number;
     get maxLevel(): number;
-    set maxLevel(value: number);
-    private _probability;
+    protected _probability: number;
     get probability(): number;
-    set probability(value: number);
     /**
      * The add function adds a new node with a given key and value to a Skip List data structure.
      * @param {K} key - The key parameter represents the key of the node that needs to be added to the skip list.
@@ -46,6 +42,7 @@ export declare class SkipList<K, V> {
      * otherwise it returns `undefined`.
      */
     get(key: K): V | undefined;
+    has(key: K): boolean;
     /**
      * The `delete` function removes a node with a specific key from a Skip List data structure.
      * @param {K} key - The key parameter represents the key of the node that needs to be removed from the skip list.
@@ -54,8 +51,30 @@ export declare class SkipList<K, V> {
      */
     delete(key: K): boolean;
     /**
-     * The function "randomLevel" generates a random level based on a given probability and maximum level.
+     * Get the value of the first element (the smallest element) in the Skip List.
+     * @returns The value of the first element, or undefined if the Skip List is empty.
+     */
+    getFirst(): V | undefined;
+    /**
+     * Get the value of the last element (the largest element) in the Skip List.
+     * @returns The value of the last element, or undefined if the Skip List is empty.
+     */
+    getLast(): V | undefined;
+    /**
+     * Get the value of the first element in the Skip List that is greater than the given key.
+     * @param key - the given key.
+     * @returns The value of the first element greater than the given key, or undefined if there is no such element.
+     */
+    higher(key: K): V | undefined;
+    /**
+     * Get the value of the last element in the Skip List that is less than the given key.
+     * @param key - the given key.
+     * @returns The value of the last element less than the given key, or undefined if there is no such element.
+     */
+    lower(key: K): V | undefined;
+    /**
+     * The function "_randomLevel" generates a random level based on a given probability and maximum level.
      * @returns the level, which is a number.
      */
-    private randomLevel;
+    protected _randomLevel(): number;
 }

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

@@ -33,27 +33,15 @@ class SkipList {
     get head() {
         return this._head;
     }
-    set head(value) {
-        this._head = value;
-    }
     get level() {
         return this._level;
     }
-    set level(value) {
-        this._level = value;
-    }
     get maxLevel() {
         return this._maxLevel;
     }
-    set maxLevel(value) {
-        this._maxLevel = value;
-    }
     get probability() {
         return this._probability;
     }
-    set probability(value) {
-        this._probability = value;
-    }
     /**
      * The add function adds a new node with a given key and value to a Skip List data structure.
      * @param {K} key - The key parameter represents the key of the node that needs to be added to the skip list.
@@ -61,7 +49,7 @@ class SkipList {
      * List.
      */
     add(key, value) {
-        const newNode = new SkipListNode(key, value, this.randomLevel());
+        const newNode = new SkipListNode(key, value, this._randomLevel());
         const update = new Array(this.maxLevel).fill(this.head);
         let current = this.head;
         for (let i = this.level - 1; i >= 0; i--) {
@@ -75,7 +63,7 @@ class SkipList {
             update[i].forward[i] = newNode;
         }
         if (newNode.forward[0] !== null) {
-            this.level = Math.max(this.level, newNode.forward.length);
+            this._level = Math.max(this.level, newNode.forward.length);
         }
     }
     /**
@@ -97,6 +85,9 @@ class SkipList {
         }
         return undefined;
     }
+    has(key) {
+        return this.get(key) !== undefined;
+    }
     /**
      * The `delete` function removes a node with a specific key from a Skip List data structure.
      * @param {K} key - The key parameter represents the key of the node that needs to be removed from the skip list.
@@ -121,17 +112,71 @@ class SkipList {
                 update[i].forward[i] = current.forward[i];
             }
             while (this.level > 0 && this.head.forward[this.level - 1] === null) {
-                this.level--;
+                this._level--;
             }
             return true;
         }
         return false;
     }
     /**
-     * The function "randomLevel" generates a random level based on a given probability and maximum level.
+     * Get the value of the first element (the smallest element) in the Skip List.
+     * @returns The value of the first element, or undefined if the Skip List is empty.
+     */
+    getFirst() {
+        const firstNode = this.head.forward[0];
+        return firstNode ? firstNode.value : undefined;
+    }
+    /**
+     * Get the value of the last element (the largest element) in the Skip List.
+     * @returns The value of the last element, or undefined if the Skip List is empty.
+     */
+    getLast() {
+        let current = this.head;
+        for (let i = this.level - 1; i >= 0; i--) {
+            while (current.forward[i]) {
+                current = current.forward[i];
+            }
+        }
+        return current.value;
+    }
+    /**
+     * Get the value of the first element in the Skip List that is greater than the given key.
+     * @param key - the given key.
+     * @returns The value of the first element greater than the given key, or undefined if there is no such element.
+     */
+    higher(key) {
+        let current = this.head;
+        for (let i = this.level - 1; i >= 0; i--) {
+            while (current.forward[i] && current.forward[i].key <= key) {
+                current = current.forward[i];
+            }
+        }
+        const nextNode = current.forward[0];
+        return nextNode ? nextNode.value : undefined;
+    }
+    /**
+     * Get the value of the last element in the Skip List that is less than the given key.
+     * @param key - the given key.
+     * @returns The value of the last element less than the given key, or undefined if there is no such element.
+     */
+    lower(key) {
+        let current = this.head;
+        let lastLess = null;
+        for (let i = this.level - 1; i >= 0; i--) {
+            while (current.forward[i] && current.forward[i].key < key) {
+                current = current.forward[i];
+            }
+            if (current.key < key) {
+                lastLess = current;
+            }
+        }
+        return lastLess ? lastLess.value : undefined;
+    }
+    /**
+     * The function "_randomLevel" generates a random level based on a given probability and maximum level.
      * @returns the level, which is a number.
      */
-    randomLevel() {
+    _randomLevel() {
         let level = 1;
         while (Math.random() < this.probability && level < this.maxLevel) {
             level++;

package/dist/data-structures/matrix/matrix.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 export declare class MatrixNTI2D<V = any> {
-    private readonly _matrix;
+    protected readonly _matrix: Array<Array<V>>;
     /**
      * The constructor creates a matrix with the specified number of rows and columns, and initializes all elements to a
      * given initial value or 0 if not provided.

package/dist/data-structures/matrix/matrix2d.d.ts

@@ -7,7 +7,7 @@
  */
 import { Vector2D } from './vector2d';
 export declare class Matrix2D {
-    private readonly _matrix;
+    protected readonly _matrix: number[][];
     /**
      * The constructor function initializes a Matrix2D object with either a default identity matrix, or a provided matrix
      * or Vector2D object.

package/dist/data-structures/matrix/navigator.d.ts

@@ -21,10 +21,10 @@ export declare class Character {
 }
 export declare class Navigator<T = number> {
     onMove: (cur: [number, number]) => void;
-    private readonly _matrix;
-    private readonly _cur;
-    private _character;
-    private readonly _VISITED;
+    protected readonly _matrix: T[][];
+    protected readonly _cur: [number, number];
+    protected _character: Character;
+    protected readonly _VISITED: T;
     /**
      * The constructor initializes the Navigator object with the given parameters and sets the current position as visited
      * in the matrix.

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

@@ -10,20 +10,19 @@ export declare class Deque<E = any> extends DoublyLinkedList<E> {
 }
 export declare class ObjectDeque<E = number> {
     constructor(capacity?: number);
-    private _nodes;
+    protected _nodes: {
+        [key: number]: E;
+    };
     get nodes(): {
         [p: number]: E;
     };
-    private _capacity;
+    protected _capacity: number;
     get capacity(): number;
-    set capacity(value: number);
-    private _first;
+    protected _first: number;
     get first(): number;
-    set first(value: number);
-    private _last;
+    protected _last: number;
     get last(): number;
-    set last(value: number);
-    private _size;
+    protected _size: number;
     get size(): number;
     /**
      * The "addFirst" function adds a value to the beginning of an array-like data structure.
@@ -69,13 +68,10 @@ export declare class ObjectDeque<E = number> {
      * @returns The method is returning a boolean value indicating whether the size of the object is less than or equal to 0.
      */
     isEmpty(): boolean;
-    protected _seNodes(value: {
-        [p: number]: E;
-    }): void;
-    protected _setSize(value: number): void;
 }
 export declare class ArrayDeque<E> {
     protected _nodes: E[];
+    get nodes(): E[];
     get size(): number;
     /**
      * O(n) time complexity of adding at the beginning and the end