graph-typed 1.39.6 → 1.41.0

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -6,34 +6,17 @@
  * @license MIT License
  */
 export 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) {
-    this._value = value;
-    this._next = null;
-  }
-
-  private _value: E;
-
-  get value(): E {
-    return this._value;
-  }
-
-  set value(value: E) {
-    this._value = value;
-  }
-
-  private _next: SinglyLinkedListNode<E> | null;
-
-  get next(): SinglyLinkedListNode<E> | null {
-    return this._next;
-  }
-
-  set next(value: SinglyLinkedListNode<E> | null) {
-    this._next = value;
+    this.value = value;
+    this.next = null;
   }
 }
 
@@ -47,27 +30,19 @@ export class SinglyLinkedList<E = any> {
     this._length = 0;
   }
 
-  private _head: SinglyLinkedListNode<E> | null;
+  protected _head: SinglyLinkedListNode<E> | null;
 
   get head(): SinglyLinkedListNode<E> | null {
     return this._head;
   }
 
-  set head(value: SinglyLinkedListNode<E> | null) {
-    this._head = value;
-  }
-
-  private _tail: SinglyLinkedListNode<E> | null;
+  protected _tail: SinglyLinkedListNode<E> | null;
 
   get tail(): SinglyLinkedListNode<E> | null {
     return this._tail;
   }
 
-  set tail(value: SinglyLinkedListNode<E> | null) {
-    this._tail = value;
-  }
-
-  private _length: number;
+  protected _length: number;
 
   get length(): number {
     return this._length;
@@ -95,11 +70,11 @@ export class SinglyLinkedList<E = any> {
   push(value: E): void {
     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++;
   }
@@ -123,8 +98,8 @@ export class SinglyLinkedList<E = any> {
     if (!this.head) 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;
     }
@@ -135,7 +110,7 @@ export class SinglyLinkedList<E = any> {
     }
     const value = this.tail!.value;
     current.next = null;
-    this.tail = current;
+    this._tail = current;
     this._length--;
     return value;
   }
@@ -157,7 +132,7 @@ export class SinglyLinkedList<E = any> {
   shift(): E | undefined {
     if (!this.head) return undefined;
     const removedNode = this.head;
-    this.head = this.head.next;
+    this._head = this.head.next;
     this._length--;
     return removedNode.value;
   }
@@ -178,11 +153,11 @@ export class SinglyLinkedList<E = any> {
   unshift(value: E): void {
     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++;
   }
@@ -267,14 +242,14 @@ export class SinglyLinkedList<E = any> {
     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--;
@@ -365,7 +340,7 @@ export class SinglyLinkedList<E = any> {
       current = next;
     }
 
-    [this.head, this.tail] = [this.tail!, this.head!];
+    [this._head, this._tail] = [this.tail!, this.head!];
   }
 
   /**
@@ -486,7 +461,7 @@ export class SinglyLinkedList<E = any> {
       newNode.next = existingNode.next;
       existingNode.next = newNode;
       if (existingNode === this.tail) {
-        this.tail = newNode;
+        this._tail = newNode;
       }
       this._length++;
       return true;
@@ -590,7 +565,7 @@ export class SinglyLinkedList<E = any> {
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

package/src/data-structures/linked-list/skip-linked-list.ts

@@ -33,46 +33,30 @@ export class SkipList<K, V> {
     this._probability = probability;
   }
 
-  private _head: SkipListNode<K, V>;
+  protected _head: SkipListNode<K, V>;
 
   get head(): SkipListNode<K, V> {
     return this._head;
   }
 
-  set head(value: SkipListNode<K, V>) {
-    this._head = value;
-  }
-
-  private _level: number;
+  protected _level: number;
 
   get level(): number {
     return this._level;
   }
 
-  set level(value: number) {
-    this._level = value;
-  }
-
-  private _maxLevel: number;
+  protected _maxLevel: number;
 
   get maxLevel(): number {
     return this._maxLevel;
   }
 
-  set maxLevel(value: number) {
-    this._maxLevel = value;
-  }
-
-  private _probability: number;
+  protected _probability: number;
 
   get probability(): number {
     return this._probability;
   }
 
-  set probability(value: number) {
-    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.
@@ -80,7 +64,7 @@ export class SkipList<K, V> {
    * List.
    */
   add(key: K, value: V): void {
-    const newNode = new SkipListNode(key, value, this.randomLevel());
+    const newNode = new SkipListNode(key, value, this._randomLevel());
     const update: SkipListNode<K, V>[] = new Array(this.maxLevel).fill(this.head);
     let current = this.head;
 
@@ -97,7 +81,7 @@ export class SkipList<K, V> {
     }
 
     if (newNode.forward[0] !== null) {
-      this.level = Math.max(this.level, newNode.forward.length);
+      this._level = Math.max(this.level, newNode.forward.length);
     }
   }
 
@@ -124,6 +108,10 @@ export class SkipList<K, V> {
     return undefined;
   }
 
+  has(key: K): boolean {
+    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.
@@ -151,7 +139,7 @@ export class SkipList<K, V> {
         update[i].forward[i] = current.forward[i];
       }
       while (this.level > 0 && this.head.forward[this.level - 1] === null) {
-        this.level--;
+        this._level--;
       }
       return true;
     }
@@ -160,10 +148,70 @@ export class SkipList<K, V> {
   }
 
   /**
-   * 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 {
+    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(): V | undefined {
+    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: K): V | undefined {
+    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: K): V | undefined {
+    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.
    */
-  private randomLevel(): number {
+  protected _randomLevel(): number {
     let level = 1;
     while (Math.random() < this.probability && level < this.maxLevel) {
       level++;

package/src/data-structures/matrix/matrix.ts

@@ -7,14 +7,14 @@
  */
 // todo need to be improved
 export class MatrixNTI2D<V = any> {
-  private readonly _matrix: Array<Array<V>>;
+  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.
    * @param options - An object containing the following properties:
    */
-  constructor(options: {row: number; col: number; initialVal?: V}) {
+  constructor(options: { row: number; col: number; initialVal?: V }) {
     const {row, col, initialVal} = options;
     this._matrix = new Array(row).fill(undefined).map(() => new Array(col).fill(initialVal || 0));
   }

package/src/data-structures/matrix/matrix2d.ts

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

package/src/data-structures/matrix/navigator.ts

@@ -27,10 +27,10 @@ export class Character {
 
 export class Navigator<T = number> {
   onMove: (cur: [number, number]) => void;
-  private readonly _matrix: T[][];
-  private readonly _cur: [number, number];
-  private _character: Character;
-  private readonly _VISITED: T;
+  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

package/src/data-structures/matrix/vector2d.ts

@@ -10,7 +10,8 @@ export class Vector2D {
     public x: number = 0,
     public y: number = 0,
     public w: number = 1 // needed for matrix multiplication
-  ) {}
+  ) {
+  }
 
   /**
    * The function checks if the x and y values of a point are both zero.

package/src/data-structures/priority-queue/max-priority-queue.ts

@@ -10,7 +10,7 @@ import type {Comparator} from '../../types';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/priority-queue/min-priority-queue.ts

@@ -10,7 +10,7 @@ import type {Comparator} from '../../types';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/priority-queue/priority-queue.ts

@@ -10,7 +10,7 @@ import {Heap} from '../heap';
 import {Comparator} from '../../types';
 
 export class PriorityQueue<E = any> extends Heap<E> {
-  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
+  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
     super(options);
   }
 }

package/src/data-structures/queue/deque.ts

@@ -9,7 +9,8 @@ import {DoublyLinkedList} from '../linked-list';
 
 // O(n) time complexity of obtaining the value
 // O(1) time complexity of adding at the beginning and the end
-export class Deque<E = any> extends DoublyLinkedList<E> {}
+export class Deque<E = any> extends DoublyLinkedList<E> {
+}
 
 // O(1) time complexity of obtaining the value
 // O(n) time complexity of adding at the beginning and the end
@@ -19,43 +20,31 @@ export class ObjectDeque<E = number> {
     if (capacity !== undefined) this._capacity = capacity;
   }
 
-  private _nodes: {[key: number]: E} = {};
+  protected _nodes: { [key: number]: E } = {};
 
-  get nodes(): {[p: number]: E} {
+  get nodes(): { [p: number]: E } {
     return this._nodes;
   }
 
-  private _capacity = Number.MAX_SAFE_INTEGER;
+  protected _capacity = Number.MAX_SAFE_INTEGER;
 
   get capacity(): number {
     return this._capacity;
   }
 
-  set capacity(value: number) {
-    this._capacity = value;
-  }
-
-  private _first = -1;
+  protected _first = -1;
 
   get first(): number {
     return this._first;
   }
 
-  set first(value: number) {
-    this._first = value;
-  }
-
-  private _last = -1;
+  protected _last = -1;
 
   get last(): number {
     return this._last;
   }
 
-  set last(value: number) {
-    this._last = value;
-  }
-
-  private _size = 0;
+  protected _size = 0;
 
   get size(): number {
     return this._size;
@@ -67,14 +56,14 @@ export class ObjectDeque<E = number> {
    * structure.
    */
   addFirst(value: E) {
-    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++;
   }
 
@@ -83,14 +72,14 @@ export class ObjectDeque<E = number> {
    * @param {E} value - The `value` parameter represents the value that you want to add to the end of the data structure.
    */
   addLast(value: E) {
-    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++;
   }
 
@@ -99,9 +88,9 @@ export class ObjectDeque<E = number> {
    * @returns The value of the first element in the data structure.
    */
   popFirst() {
-    if (!this._size) return;
+    if (!this.size) return;
     const value = this.getFirst();
-    delete this._nodes[this._first];
+    delete this.nodes[this.first];
     this._first++;
     this._size--;
     return value;
@@ -112,7 +101,7 @@ export class ObjectDeque<E = number> {
    * @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];
   }
 
   /**
@@ -120,9 +109,9 @@ export class ObjectDeque<E = number> {
    * @returns The value that was removed from the data structure.
    */
   popLast() {
-    if (!this._size) return;
+    if (!this.size) return;
     const value = this.getLast();
-    delete this._nodes[this._last];
+    delete this.nodes[this.last];
     this._last--;
     this._size--;
 
@@ -134,7 +123,7 @@ export class ObjectDeque<E = number> {
    * @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];
   }
 
   /**
@@ -145,7 +134,7 @@ export class ObjectDeque<E = number> {
    * index, `null` is returned.
    */
   get(index: number) {
-    return this._nodes[this._first + index] || null;
+    return this.nodes[this.first + index] || null;
   }
 
   /**
@@ -153,15 +142,7 @@ export 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() {
-    return this._size <= 0;
-  }
-
-  protected _seNodes(value: {[p: number]: E}) {
-    this._nodes = value;
-  }
-
-  protected _setSize(value: number) {
-    this._size = value;
+    return this.size <= 0;
   }
 }
 
@@ -170,8 +151,12 @@ export class ObjectDeque<E = number> {
 export class ArrayDeque<E> {
   protected _nodes: E[] = [];
 
+  get nodes(): E[] {
+    return this._nodes;
+  }
+
   get size() {
-    return this._nodes.length;
+    return this.nodes.length;
   }
 
   /**
@@ -184,7 +169,7 @@ export class ArrayDeque<E> {
    * @returns The return value is the new length of the array after the value has been added.
    */
   addLast(value: E) {
-    return this._nodes.push(value);
+    return this.nodes.push(value);
   }
 
   /**
@@ -192,7 +177,7 @@ export class ArrayDeque<E> {
    * @returns The method `popLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
    */
   popLast(): E | null {
-    return this._nodes.pop() ?? null;
+    return this.nodes.pop() ?? null;
   }
 
   /**
@@ -201,7 +186,7 @@ export class ArrayDeque<E> {
    * empty.
    */
   popFirst(): E | null {
-    return this._nodes.shift() ?? null;
+    return this.nodes.shift() ?? null;
   }
 
   /**
@@ -215,7 +200,7 @@ export class ArrayDeque<E> {
    * `value` at the beginning.
    */
   addFirst(value: E) {
-    return this._nodes.unshift(value);
+    return this.nodes.unshift(value);
   }
 
   /**
@@ -224,7 +209,7 @@ export class ArrayDeque<E> {
    * empty, it will return `null`.
    */
   getFirst(): E | null {
-    return this._nodes[0] ?? null;
+    return this.nodes[0] ?? null;
   }
 
   /**
@@ -232,7 +217,7 @@ export class ArrayDeque<E> {
    * @returns The method `getLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
    */
   getLast(): E | null {
-    return this._nodes[this._nodes.length - 1] ?? null;
+    return this.nodes[this.nodes.length - 1] ?? null;
   }
 
   /**
@@ -247,7 +232,7 @@ export class ArrayDeque<E> {
    * will be returned. If the element does not exist (i.e., the index is out of bounds), `null` will be returned.
    */
   get(index: number): E | null {
-    return this._nodes[index] ?? null;
+    return this.nodes[index] ?? null;
   }
 
   /**
@@ -259,7 +244,7 @@ export class ArrayDeque<E> {
    * @returns The value that is being set at the specified index in the `_nodes` array.
    */
   set(index: number, value: E) {
-    return (this._nodes[index] = value);
+    return (this.nodes[index] = value);
   }
 
   /**
@@ -273,7 +258,7 @@ export class ArrayDeque<E> {
    * are being removed, an empty array will be returned.
    */
   insert(index: number, value: E) {
-    return this._nodes.splice(index, 0, value);
+    return this.nodes.splice(index, 0, value);
   }
 
   /**
@@ -283,7 +268,7 @@ export class ArrayDeque<E> {
    * @returns The method is returning an array containing the removed element.
    */
   delete(index: number) {
-    return this._nodes.splice(index, 1);
+    return this.nodes.splice(index, 1);
   }
 
   /**
@@ -292,6 +277,6 @@ export class ArrayDeque<E> {
    * is 0, indicating that the array is empty. Otherwise, it returns `false`.
    */
   isEmpty() {
-    return this._nodes.length === 0;
+    return this.nodes.length === 0;
   }
 }