data-structure-typed 1.39.6 → 1.40.0

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

@@ -9,28 +9,16 @@ exports.SinglyLinkedList = exports.SinglyLinkedListNode = void 0;
  * @license MIT License
  */
 class SinglyLinkedListNode {
+    value;
+    next;
     /**
      * 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) {
-        this._value = value;
-        this._next = null;
-    }
-    _value;
-    get value() {
-        return this._value;
-    }
-    set value(value) {
-        this._value = value;
-    }
-    _next;
-    get next() {
-        return this._next;
-    }
-    set next(value) {
-        this._next = value;
+        this.value = value;
+        this.next = null;
     }
 }
 exports.SinglyLinkedListNode = SinglyLinkedListNode;
@@ -47,16 +35,10 @@ class SinglyLinkedList {
     get head() {
         return this._head;
     }
-    set head(value) {
-        this._head = value;
-    }
     _tail;
     get tail() {
         return this._tail;
     }
-    set tail(value) {
-        this._tail = value;
-    }
     _length;
     get length() {
         return this._length;
@@ -82,12 +64,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++;
     }
@@ -110,8 +92,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;
         }
@@ -121,7 +103,7 @@ class SinglyLinkedList {
         }
         const value = this.tail.value;
         current.next = null;
-        this.tail = current;
+        this._tail = current;
         this._length--;
         return value;
     }
@@ -142,7 +124,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;
     }
@@ -161,12 +143,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++;
     }
@@ -249,15 +231,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--;
@@ -340,7 +322,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.
@@ -450,7 +432,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/mjs/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/mjs/data-structures/linked-list/skip-linked-list.js

@@ -37,30 +37,18 @@ class SkipList {
     get head() {
         return this._head;
     }
-    set head(value) {
-        this._head = value;
-    }
     _level;
     get level() {
         return this._level;
     }
-    set level(value) {
-        this._level = value;
-    }
     _maxLevel;
     get maxLevel() {
         return this._maxLevel;
     }
-    set maxLevel(value) {
-        this._maxLevel = value;
-    }
     _probability;
     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.
@@ -68,7 +56,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--) {
@@ -82,7 +70,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);
         }
     }
     /**
@@ -104,6 +92,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.
@@ -128,17 +119,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/mjs/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/mjs/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/mjs/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/mjs/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

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

@@ -30,23 +30,14 @@ class ObjectDeque {
     get capacity() {
         return this._capacity;
     }
-    set capacity(value) {
-        this._capacity = value;
-    }
     _first = -1;
     get first() {
         return this._first;
     }
-    set first(value) {
-        this._first = value;
-    }
     _last = -1;
     get last() {
         return this._last;
     }
-    set last(value) {
-        this._last = value;
-    }
     _size = 0;
     get size() {
         return this._size;
@@ -57,15 +48,15 @@ class ObjectDeque {
      * structure.
      */
     addFirst(value) {
-        if (this._size === 0) {
-            const mid = Math.floor(this._capacity / 2);
+        if (this.size === 0) {
+            const mid = Math.floor(this.capacity / 2);
             this._first = mid;
             this._last = mid;
         }
         else {
             this._first--;
         }
-        this._nodes[this._first] = value;
+        this.nodes[this.first] = value;
         this._size++;
     }
     /**
@@ -73,15 +64,15 @@ class ObjectDeque {
      * @param {E} value - The `value` parameter represents the value that you want to add to the end of the data structure.
      */
     addLast(value) {
-        if (this._size === 0) {
-            const mid = Math.floor(this._capacity / 2);
+        if (this.size === 0) {
+            const mid = Math.floor(this.capacity / 2);
             this._first = mid;
             this._last = mid;
         }
         else {
             this._last++;
         }
-        this._nodes[this._last] = value;
+        this.nodes[this.last] = value;
         this._size++;
     }
     /**
@@ -89,10 +80,10 @@ class ObjectDeque {
      * @returns The value of the first element in the data structure.
      */
     popFirst() {
-        if (!this._size)
+        if (!this.size)
             return;
         const value = this.getFirst();
-        delete this._nodes[this._first];
+        delete this.nodes[this.first];
         this._first++;
         this._size--;
         return value;
@@ -102,18 +93,18 @@ class ObjectDeque {
      * @returns The element at the first position of the `_nodes` array.
      */
     getFirst() {
-        if (this._size)
-            return this._nodes[this._first];
+        if (this.size)
+            return this.nodes[this.first];
     }
     /**
      * The `popLast()` function removes and returns the last element in a data structure.
      * @returns The value that was removed from the data structure.
      */
     popLast() {
-        if (!this._size)
+        if (!this.size)
             return;
         const value = this.getLast();
-        delete this._nodes[this._last];
+        delete this.nodes[this.last];
         this._last--;
         this._size--;
         return value;
@@ -123,8 +114,8 @@ class ObjectDeque {
      * @returns The last element in the array "_nodes" is being returned.
      */
     getLast() {
-        if (this._size)
-            return this._nodes[this._last];
+        if (this.size)
+            return this.nodes[this.last];
     }
     /**
      * The get function returns the element at the specified index in an array-like data structure.
@@ -134,20 +125,14 @@ class ObjectDeque {
      * index, `null` is returned.
      */
     get(index) {
-        return this._nodes[this._first + index] || null;
+        return this.nodes[this.first + index] || null;
     }
     /**
      * The function checks if the size of a data structure is less than or equal to zero.
      * @returns The method is returning a boolean value indicating whether the size of the object is less than or equal to 0.
      */
     isEmpty() {
-        return this._size <= 0;
-    }
-    _seNodes(value) {
-        this._nodes = value;
-    }
-    _setSize(value) {
-        this._size = value;
+        return this.size <= 0;
     }
 }
 exports.ObjectDeque = ObjectDeque;
@@ -155,8 +140,11 @@ exports.ObjectDeque = ObjectDeque;
 // O(n) time complexity of adding at the beginning and the end
 class ArrayDeque {
     _nodes = [];
+    get nodes() {
+        return this._nodes;
+    }
     get size() {
-        return this._nodes.length;
+        return this.nodes.length;
     }
     /**
      * O(n) time complexity of adding at the beginning and the end
@@ -167,14 +155,14 @@ class ArrayDeque {
      * @returns The return value is the new length of the array after the value has been added.
      */
     addLast(value) {
-        return this._nodes.push(value);
+        return this.nodes.push(value);
     }
     /**
      * The function "popLast" returns and removes the last element from an array, or returns null if the array is empty.
      * @returns The method `popLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
      */
     popLast() {
-        return this._nodes.pop() ?? null;
+        return this.nodes.pop() ?? null;
     }
     /**
      * The `popFirst` function removes and returns the first element from an array, or returns null if the array is empty.
@@ -182,7 +170,7 @@ class ArrayDeque {
      * empty.
      */
     popFirst() {
-        return this._nodes.shift() ?? null;
+        return this.nodes.shift() ?? null;
     }
     /**
      * O(n) time complexity of adding at the beginning and the end
@@ -194,7 +182,7 @@ class ArrayDeque {
      * `value` at the beginning.
      */
     addFirst(value) {
-        return this._nodes.unshift(value);
+        return this.nodes.unshift(value);
     }
     /**
      * The `getFirst` function returns the first element of an array or null if the array is empty.
@@ -202,14 +190,14 @@ class ArrayDeque {
      * empty, it will return `null`.
      */
     getFirst() {
-        return this._nodes[0] ?? null;
+        return this.nodes[0] ?? null;
     }
     /**
      * The `getLast` function returns the last element of an array or null if the array is empty.
      * @returns The method `getLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
      */
     getLast() {
-        return this._nodes[this._nodes.length - 1] ?? null;
+        return this.nodes[this.nodes.length - 1] ?? null;
     }
     /**
      * O(1) time complexity of obtaining the value
@@ -222,7 +210,7 @@ class ArrayDeque {
      * will be returned. If the element does not exist (i.e., the index is out of bounds), `null` will be returned.
      */
     get(index) {
-        return this._nodes[index] ?? null;
+        return this.nodes[index] ?? null;
     }
     /**
      * The set function assigns a value to a specific index in an array.
@@ -233,7 +221,7 @@ class ArrayDeque {
      * @returns The value that is being set at the specified index in the `_nodes` array.
      */
     set(index, value) {
-        return (this._nodes[index] = value);
+        return (this.nodes[index] = value);
     }
     /**
      * The insert function adds a value at a specified index in an array.
@@ -246,7 +234,7 @@ class ArrayDeque {
      * are being removed, an empty array will be returned.
      */
     insert(index, value) {
-        return this._nodes.splice(index, 0, value);
+        return this.nodes.splice(index, 0, value);
     }
     /**
      * The delete function removes an element from an array at a specified index.
@@ -255,7 +243,7 @@ class ArrayDeque {
      * @returns The method is returning an array containing the removed element.
      */
     delete(index) {
-        return this._nodes.splice(index, 1);
+        return this.nodes.splice(index, 1);
     }
     /**
      * The function checks if an array called "_nodes" is empty.
@@ -263,7 +251,7 @@ class ArrayDeque {
      * is 0, indicating that the array is empty. Otherwise, it returns `false`.
      */
     isEmpty() {
-        return this._nodes.length === 0;
+        return this.nodes.length === 0;
     }
 }
 exports.ArrayDeque = ArrayDeque;