min-heap-typed 1.38.0 → 1.38.1

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

@@ -0,0 +1,23 @@
+/**
+ * data-structure-typed
+ *
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @license MIT License
+ */
+import {PriorityQueue} from './priority-queue';
+import type {Comparator} from '../../types';
+
+export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
+  constructor(
+    compare: Comparator<E> = (a: E, b: E) => {
+      if (!(typeof a === 'number' && typeof b === 'number')) {
+        throw new Error('The a, b params of compare function must be number');
+      } else {
+        return a - b;
+      }
+    }
+  ) {
+    super(compare);
+  }
+}

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

@@ -0,0 +1,16 @@
+/**
+ * data-structure-typed
+ *
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @license MIT License
+ */
+
+import {Heap} from '../heap';
+import {Comparator} from '../../types';
+
+export class PriorityQueue<E> extends Heap<E> {
+  constructor(comparator: Comparator<E>) {
+    super(comparator);
+  }
+}

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

@@ -0,0 +1,297 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+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> {}
+
+// O(1) time complexity of obtaining the value
+// O(n) time complexity of adding at the beginning and the end
+// todo tested slowest one
+export class ObjectDeque<E = number> {
+  constructor(capacity?: number) {
+    if (capacity !== undefined) this._capacity = capacity;
+  }
+
+  private _nodes: {[key: number]: E} = {};
+
+  get nodes(): {[p: number]: E} {
+    return this._nodes;
+  }
+
+  private _capacity = Number.MAX_SAFE_INTEGER;
+
+  get capacity(): number {
+    return this._capacity;
+  }
+
+  set capacity(value: number) {
+    this._capacity = value;
+  }
+
+  private _first = -1;
+
+  get first(): number {
+    return this._first;
+  }
+
+  set first(value: number) {
+    this._first = value;
+  }
+
+  private _last = -1;
+
+  get last(): number {
+    return this._last;
+  }
+
+  set last(value: number) {
+    this._last = value;
+  }
+
+  private _size = 0;
+
+  get size(): number {
+    return this._size;
+  }
+
+  /**
+   * The "addFirst" function adds a value to the beginning of an array-like data structure.
+   * @param {E} value - The `value` parameter represents the value that you want to add to the beginning of the data
+   * structure.
+   */
+  addFirst(value: E) {
+    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._size++;
+  }
+
+  /**
+   * The addLast function adds a value to the end of an array-like data structure.
+   * @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);
+      this._first = mid;
+      this._last = mid;
+    } else {
+      this._last++;
+    }
+    this._nodes[this._last] = value;
+    this._size++;
+  }
+
+  /**
+   * The function `pollFirst()` removes and returns the first element in a data structure.
+   * @returns The value of the first element in the data structure.
+   */
+  pollFirst() {
+    if (!this._size) return;
+    const value = this.peekFirst();
+    delete this._nodes[this._first];
+    this._first++;
+    this._size--;
+    return value;
+  }
+
+  /**
+   * The `peekFirst` function returns the first element in an array-like data structure if it exists.
+   * @returns The element at the first position of the `_nodes` array.
+   */
+  peekFirst() {
+    if (this._size) return this._nodes[this._first];
+  }
+
+  /**
+   * The `pollLast()` function removes and returns the last element in a data structure.
+   * @returns The value that was removed from the data structure.
+   */
+  pollLast() {
+    if (!this._size) return;
+    const value = this.peekLast();
+    delete this._nodes[this._last];
+    this._last--;
+    this._size--;
+
+    return value;
+  }
+
+  /**
+   * The `peekLast()` function returns the last element in an array-like data structure.
+   * @returns The last element in the array "_nodes" is being returned.
+   */
+  peekLast() {
+    if (this._size) return this._nodes[this._last];
+  }
+
+  /**
+   * The get function returns the element at the specified index in an array-like data structure.
+   * @param {number} index - The index parameter is a number that represents the position of the element you want to
+   * retrieve from the array.
+   * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
+   * index, `null` is returned.
+   */
+  get(index: number) {
+    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;
+  }
+
+  protected _seNodes(value: {[p: number]: E}) {
+    this._nodes = value;
+  }
+
+  protected _setSize(value: number) {
+    this._size = value;
+  }
+}
+
+// O(1) time complexity of obtaining the value
+// O(n) time complexity of adding at the beginning and the end
+export class ArrayDeque<E> {
+  protected _nodes: E[] = [];
+
+  get size() {
+    return this._nodes.length;
+  }
+
+  /**
+   * O(n) time complexity of adding at the beginning and the end
+   */
+
+  /**
+   * The function "addLast" adds a value to the end of an array.
+   * @param {E} value - The value parameter represents the value that you want to add to the end of the array.
+   * @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);
+  }
+
+  /**
+   * The function "pollLast" returns and removes the last element from an array, or returns null if the array is empty.
+   * @returns The method `pollLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+   */
+  pollLast(): E | null {
+    return this._nodes.pop() ?? null;
+  }
+
+  /**
+   * The `pollFirst` function removes and returns the first element from an array, or returns null if the array is empty.
+   * @returns The `pollFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
+   * empty.
+   */
+  pollFirst(): E | null {
+    return this._nodes.shift() ?? null;
+  }
+
+  /**
+   * O(n) time complexity of adding at the beginning and the end
+   */
+
+  /**
+   * The function "addFirst" adds a value to the beginning of an array.
+   * @param {E} value - The value parameter represents the value that you want to add to the beginning of the array.
+   * @returns The return value of the `addFirst` function is the new length of the array `_nodes` after adding the
+   * `value` at the beginning.
+   */
+  addFirst(value: E) {
+    return this._nodes.unshift(value);
+  }
+
+  /**
+   * The `peekFirst` function returns the first element of an array or null if the array is empty.
+   * @returns The function `peekFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
+   * empty, it will return `null`.
+   */
+  peekFirst(): E | null {
+    return this._nodes[0] ?? null;
+  }
+
+  /**
+   * The `peekLast` function returns the last element of an array or null if the array is empty.
+   * @returns The method `peekLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+   */
+  peekLast(): E | null {
+    return this._nodes[this._nodes.length - 1] ?? null;
+  }
+
+  /**
+   * O(1) time complexity of obtaining the value
+   */
+
+  /**
+   * The get function returns the element at the specified index in an array, or null if the index is out of bounds.
+   * @param {number} index - The index parameter is a number that represents the position of the element you want to
+   * retrieve from the array.
+   * @returns The method is returning the element at the specified index in the `_nodes` array. If the element exists, it
+   * 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;
+  }
+
+  /**
+   * The set function assigns a value to a specific index in an array.
+   * @param {number} index - The index parameter is a number that represents the position of the element in the array
+   * that you want to set a new value for.
+   * @param {E} value - The value parameter represents the new value that you want to set at the specified index in the
+   * _nodes array.
+   * @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);
+  }
+
+  /**
+   * The insert function adds a value at a specified index in an array.
+   * @param {number} index - The index parameter specifies the position at which the value should be inserted in the
+   * array. It is a number that represents the index of the array where the value should be inserted. The index starts
+   * from 0, so the first element of the array has an index of 0, the second element has
+   * @param {E} value - The value parameter represents the value that you want to insert into the array at the specified
+   * index.
+   * @returns The splice method returns an array containing the removed elements, if any. In this case, since no elements
+   * are being removed, an empty array will be returned.
+   */
+  insert(index: number, value: E) {
+    return this._nodes.splice(index, 0, value);
+  }
+
+  /**
+   * The delete function removes an element from an array at a specified index.
+   * @param {number} index - The index parameter specifies the position of the element to be removed from the array. It
+   * is a number that represents the index of the element to be removed.
+   * @returns The method is returning an array containing the removed element.
+   */
+  delete(index: number) {
+    return this._nodes.splice(index, 1);
+  }
+
+  /**
+   * The function checks if an array called "_nodes" is empty.
+   * @returns The method `isEmpty()` is returning a boolean value. It returns `true` if the length of the `_nodes` array
+   * is 0, indicating that the array is empty. Otherwise, it returns `false`.
+   */
+  isEmpty() {
+    return this._nodes.length === 0;
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './queue';
+export * from './deque';

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

@@ -0,0 +1,191 @@
+/**
+ * @license MIT
+ * @copyright Tyler Zeng <zrwusa@gmail.com>
+ * @class
+ */
+import {SinglyLinkedList} from '../linked-list';
+
+export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
+  /**
+   * The enqueue function adds a value to the end of an array.
+   * @param {E} value - The value parameter represents the value that you want to add to the queue.
+   */
+  enqueue(value: E) {
+    this.push(value);
+  }
+
+  /**
+   * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
+   * @returns The method is returning the element at the front of the queue, or null if the queue is empty.
+   */
+  dequeue(): E | undefined {
+    return this.shift();
+  }
+
+  /**
+   * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+   * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+   */
+  peek(): E | undefined {
+    return this.head?.val;
+  }
+}
+
+export class Queue<E = any> {
+  /**
+   * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
+   * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
+   * will be used to initialize the `_nodes` property of the class. If not provided, the `_nodes` property will be
+   * initialized as an empty array.
+   */
+  constructor(elements?: E[]) {
+    this._nodes = elements || [];
+    this._offset = 0;
+  }
+
+  private _nodes: E[];
+
+  get nodes(): E[] {
+    return this._nodes;
+  }
+
+  set nodes(value: E[]) {
+    this._nodes = value;
+  }
+
+  private _offset: number;
+
+  get offset(): number {
+    return this._offset;
+  }
+
+  set offset(value: number) {
+    this._offset = value;
+  }
+
+  /**
+   * The size function returns the number of elements in an array.
+   * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
+   */
+  get size(): number {
+    return this.nodes.length - this.offset;
+  }
+
+  /**
+   * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
+   * @public
+   * @static
+   * @param {E[]} elements - The "elements" parameter is an array of elements of type E.
+   * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
+   * array.
+   */
+  static fromArray<E>(elements: E[]): Queue<E> {
+    return new Queue(elements);
+  }
+
+  /**
+   * The push function adds an element to the end of the queue and returns the updated queue.Adds an element at the back of the queue.
+   * @param {E} element - The `element` parameter represents the element that you want to add to the queue.
+   * @returns The `add` method is returning a `Queue<E>` object.
+   */
+  push(element: E): Queue<E> {
+    this.nodes.push(element);
+    return this;
+  }
+
+  /**
+   * The `shift` function removes and returns the first element in the queue, and adjusts the internal data structure if
+   * necessary to optimize performance.
+   * @returns The function `shift()` returns either the first element in the queue or `null` if the queue is empty.
+   */
+  shift(): E | undefined {
+    if (this.size === 0) return undefined;
+
+    const first = this.peek();
+    this.offset += 1;
+
+    if (this.offset * 2 < this.nodes.length) return first;
+
+    // only delete dequeued elements when reaching half size
+    // to decrease latency of shifting elements.
+    this.nodes = this.nodes.slice(this.offset);
+    this.offset = 0;
+    return first;
+  }
+
+  /**
+   * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
+   * @returns The `peek()` method returns the first element of the data structure, represented by the `_nodes` array at
+   * the `_offset` index. If the data structure is empty (size is 0), it returns `null`.
+   */
+  peek(): E | undefined {
+    return this.size > 0 ? this.nodes[this.offset] : undefined;
+  }
+
+  /**
+   * The `peekLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+   * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
+   * array is empty, it returns `null`.
+   */
+  peekLast(): E | undefined {
+    return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
+  }
+
+  /**
+   * The enqueue function adds a value to the end of a queue.
+   * @param {E} value - The value parameter represents the value that you want to add to the queue.
+   */
+  enqueue(value: E) {
+    this.push(value);
+  }
+
+  /**
+   * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
+   * @returns The method is returning a value of type E or null.
+   */
+  dequeue(): E | undefined {
+    return this.shift();
+  }
+
+  getAt(index: number): E | undefined {
+    return this.nodes[index];
+  }
+
+  /**
+   * The function checks if a data structure is empty by comparing its size to zero.
+   * @returns {boolean} A boolean value indicating whether the size of the object is 0 or not.
+   */
+  isEmpty(): boolean {
+    return this.size === 0;
+  }
+
+  /**
+   * The toArray() function returns an array of elements from the current offset to the end of the _nodes array.
+   * @returns An array of type E is being returned.
+   */
+  toArray(): E[] {
+    return this.nodes.slice(this.offset);
+  }
+
+  /**
+   * The clear function resets the nodes array and offset to their initial values.
+   */
+  clear(): void {
+    this.nodes = [];
+    this.offset = 0;
+  }
+
+  /**
+   * The `clone()` function returns a new Queue object with the same elements as the original Queue.
+   * @returns The `clone()` method is returning a new instance of the `Queue` class.
+   */
+  clone(): Queue<E> {
+    return new Queue(this.nodes.slice(this.offset));
+  }
+
+  *[Symbol.iterator]() {
+    for (const item of this.nodes) {
+      yield item;
+    }
+  }
+}

package/src/data-structures/stack/index.ts

@@ -0,0 +1 @@
+export * from './stack';

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

@@ -0,0 +1,98 @@
+/**
+ * @license MIT
+ * @copyright Tyler Zeng <zrwusa@gmail.com>
+ * @class
+ */
+export class Stack<E = any> {
+  protected _elements: E[];
+
+  /**
+   * The constructor initializes an array of elements, which can be provided as an optional parameter.
+   * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
+   * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
+   * is provided and is an array, it is assigned to the `_elements
+   */
+  constructor(elements?: E[]) {
+    this._elements = Array.isArray(elements) ? elements : [];
+  }
+
+  /**
+   * The function "fromArray" creates a new Stack object from an array of elements.
+   * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
+   * @returns {Stack} The method is returning a new instance of the Stack class, initialized with the elements from the input
+   * array.
+   */
+  static fromArray<E>(elements: E[]): Stack<E> {
+    return new Stack(elements);
+  }
+
+  /**
+   * The function checks if an array is empty and returns a boolean value.
+   * @returns A boolean value indicating whether the `_elements` array is empty or not.
+   */
+  isEmpty(): boolean {
+    return this._elements.length === 0;
+  }
+
+  /**
+   * The size() function returns the number of elements in an array.
+   * @returns The size of the elements array.
+   */
+  size(): number {
+    return this._elements.length;
+  }
+
+  /**
+   * The `peek` function returns the last element of an array, or null if the array is empty.
+   * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
+   */
+  peek(): E | null {
+    if (this.isEmpty()) return null;
+
+    return this._elements[this._elements.length - 1];
+  }
+
+  /**
+   * The push function adds an element to the stack and returns the updated stack.
+   * @param {E} element - The parameter "element" is of type E, which means it can be any data type.
+   * @returns The `push` method is returning the updated `Stack<E>` object.
+   */
+  push(element: E): Stack<E> {
+    this._elements.push(element);
+    return this;
+  }
+
+  /**
+   * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
+   * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
+   * array is empty, it returns `null`.
+   */
+  pop(): E | null {
+    if (this.isEmpty()) return null;
+
+    return this._elements.pop() || null;
+  }
+
+  /**
+   * The toArray function returns a copy of the elements in an array.
+   * @returns An array of type E.
+   */
+  toArray(): E[] {
+    return this._elements.slice();
+  }
+
+  /**
+   * The clear function clears the elements array.
+   */
+  clear(): void {
+    this._elements = [];
+  }
+
+  /**
+   * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
+   * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
+   */
+  clone(): Stack<E> {
+    return new Stack(this._elements.slice());
+  }
+}

package/src/data-structures/tree/index.ts

@@ -0,0 +1 @@
+export * from './tree';

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

@@ -0,0 +1,67 @@
+export class TreeNode<V = any> {
+  constructor(key: string, value?: V, children?: TreeNode<V>[]) {
+    this._key = key;
+    this._value = value || undefined;
+    this._children = children || [];
+  }
+
+  private _key: string;
+
+  get key(): string {
+    return this._key;
+  }
+
+  set key(value: string) {
+    this._key = value;
+  }
+
+  private _value?: V | undefined;
+
+  get value(): V | undefined {
+    return this._value;
+  }
+
+  set value(value: V | undefined) {
+    this._value = value;
+  }
+
+  private _children?: TreeNode<V>[] | undefined;
+
+  get children(): TreeNode<V>[] | undefined {
+    return this._children;
+  }
+
+  set children(value: TreeNode<V>[] | undefined) {
+    this._children = value;
+  }
+
+  addChildren(children: TreeNode<V> | TreeNode<V>[]) {
+    if (!this.children) {
+      this.children = [];
+    }
+    if (children instanceof TreeNode) {
+      this.children.push(children);
+    } else {
+      this.children = this.children.concat(children);
+    }
+  }
+
+  getHeight() {
+    let maxDepth = 0;
+    if (this) {
+      const bfs = (node: TreeNode<V>, level: number) => {
+        if (level > maxDepth) {
+          maxDepth = level;
+        }
+        const {children} = node;
+        if (children) {
+          for (let i = 0, len = children.length; i < len; i++) {
+            bfs(children[i], level + 1);
+          }
+        }
+      };
+      bfs(this, 0);
+    }
+    return maxDepth;
+  }
+}

package/src/data-structures/trie/index.ts

@@ -0,0 +1 @@
+export * from './trie';