data-structure-typed 1.15.2 → 1.16.1

package/src/data-structures/graph/undirected-graph.ts

@@ -1,259 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import {arrayRemove} from '../../utils';
-import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
-import type {VertexId} from '../types';
-
-export class UndirectedVertex extends AbstractVertex {
-    /**
-     * The constructor function initializes an object with a given id.
-     * @param {VertexId} id - The `id` parameter is the identifier for the vertex. It is used to uniquely identify the
-     * vertex within a graph or network.
-     */
-    constructor(id: VertexId) {
-        super(id);
-    }
-}
-
-export class UndirectedEdge extends AbstractEdge {
-    /**
-     * The constructor function initializes an instance of a class with two vertex IDs and an optional weight.
-     * @param {VertexId} v1 - The parameter `v1` is of type `VertexId` and represents the first vertex in the edge.
-     * @param {VertexId} v2 - The parameter `v2` is a `VertexId`, which represents the identifier of the second vertex in a
-     * graph.
-     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge
-     * between two vertices.
-     */
-    constructor(v1: VertexId, v2: VertexId, weight?: number) {
-        super(weight);
-        this._vertices = [v1, v2];
-    }
-
-    private _vertices: [VertexId, VertexId];
-    get vertices() {
-        return this._vertices;
-    }
-
-    set vertices(v: [VertexId, VertexId]) {
-        this._vertices = v;
-    }
-
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getVertices() {
-        return this._vertices;
-    }
-}
-
-export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdge> extends AbstractGraph<V, E> {
-    constructor() {
-        super();
-        this._edges = new Map<V, E[]>();
-    }
-
-    protected _edges: Map<V, E[]>;
-
-    get edges(): Map<V, E[]> {
-        return this._edges;
-    }
-
-    protected set edges(v: Map<V, E[]>) {
-        this._edges = v;
-    }
-
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getEdges(): Map<V, E[]> {
-        return this._edges;
-    }
-
-    /**
-     * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
-     * @param {V | null | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID
-     * (`VertexId`). It can also be `null`.
-     * @param {V | null | VertexId} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `V` (vertex
-     * object), `null`, or `VertexId` (vertex ID).
-     * @returns an edge (E) or null.
-     */
-    getEdge(v1: V | null | VertexId, v2: V | null | VertexId): E | null {
-        let edges: E[] | undefined = [];
-
-        if (v1 !== null && v2 !== null) {
-            const vertex1: V | null = this.getVertex(v1);
-            const vertex2: V | null = this.getVertex(v2);
-
-            if (vertex1 && vertex2) {
-                edges = this._edges.get(vertex1)?.filter(e => e.vertices.includes(vertex2.id));
-            }
-        }
-
-        return edges ? edges[0] || null : null;
-    }
-
-    /**
-     * The function adds an edge to a graph by connecting two vertices.
-     * @param {E} edge - The `edge` parameter is an object of type `E`, which represents an edge in a graph.
-     * @returns a boolean value.
-     */
-    addEdge(edge: E): boolean {
-        for (const end of edge.vertices) {
-            const endVertex = this.getVertex(end);
-            if (endVertex === null) return false;
-            if (endVertex) {
-                const edges = this._edges.get(endVertex);
-                if (edges) {
-                    edges.push(edge);
-                } else {
-                    this._edges.set(endVertex, [edge]);
-                }
-            }
-        }
-        return true;
-    }
-
-    /**
-     * The function removes an edge between two vertices in a graph and returns the removed edge, or null if either of the
-     * vertices does not exist.
-     * @param {V | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexId`).
-     * @param {V | VertexId} v2 - V | VertexId: The second vertex or vertex ID of the edge to be removed.
-     * @returns the removed edge (E) if it exists, or null if either of the vertices (v1 or v2) does not exist.
-     */
-    removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): E | null {
-
-        const vertex1: V | null = this.getVertex(v1);
-        const vertex2: V | null = this.getVertex(v2);
-
-        if (!vertex1 || !vertex2) {
-            return null;
-        }
-
-        const v1Edges = this._edges.get(vertex1);
-        let removed: E | null = null;
-        if (v1Edges) {
-            removed = arrayRemove<E>(v1Edges, (e: UndirectedEdge) => e.vertices.includes(vertex2.id))[0] || null;
-        }
-        const v2Edges = this._edges.get(vertex2);
-        if (v2Edges) {
-            arrayRemove<E>(v2Edges, (e: UndirectedEdge) => e.vertices.includes(vertex1.id));
-        }
-        return removed;
-    }
-
-    /**
-     * The removeEdge function removes an edge between two vertices in a graph.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
-     * @returns The method is returning either the removed edge (of type E) or null if the edge was not found.
-     */
-    removeEdge(edge: E): E | null {
-        return this.removeEdgeBetween(edge.vertices[0], edge.vertices[1]);
-    }
-
-    /**
-     * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges connected to that
-     * vertex.
-     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
-     * @returns The function `degreeOf` returns the degree of a vertex in a graph. The degree of a vertex is the number of
-     * edges that are incident to that vertex.
-     */
-    degreeOf(vertexOrId: VertexId | V): number {
-        const vertex = this.getVertex(vertexOrId);
-        if (vertex) {
-            return this._edges.get(vertex)?.length || 0;
-        } else {
-            return 0;
-        }
-    }
-
-    /**
-     * The function "edgesOf" returns an array of edges connected to a given vertex.
-     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
-     * @returns an array of edges connected to the specified vertex. If the vertex exists in the graph, the function
-     * returns the array of edges connected to that vertex. If the vertex does not exist in the graph, the function returns
-     * an empty array.
-     */
-    edgesOf(vertexOrId: VertexId | V): E[] {
-        const vertex = this.getVertex(vertexOrId);
-        if (vertex) {
-            return this._edges.get(vertex) || [];
-        } else {
-            return [];
-        }
-    }
-
-    /**
-     * The function "edgeSet" returns an array of unique edges from a set of edges.
-     * @returns The method `edgeSet()` returns an array of type `E[]`.
-     */
-    edgeSet(): E[] {
-        const edgeSet: Set<E> = new Set();
-        this._edges.forEach(edges => {
-            edges.forEach(edge => {
-                edgeSet.add(edge);
-            });
-        });
-        return [...edgeSet];
-    }
-
-    /**
-     * The function "getEdgesOf" returns an array of edges connected to a given vertex or vertex ID.
-     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can accept either a vertex object (`V`) or a vertex ID
-     * (`VertexId`).
-     * @returns an array of edges (E[]) that are connected to the specified vertex or vertex ID.
-     */
-    getEdgesOf(vertexOrId: V | VertexId): E[] {
-        const vertex = this.getVertex(vertexOrId);
-        if (!vertex) {
-            return [];
-        }
-        return this._edges.get(vertex) || [];
-    }
-
-    /**
-     * The function "getNeighbors" returns an array of neighboring vertices of a given vertex.
-     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
-     * (`VertexId`).
-     * @returns an array of vertices (V[]).
-     */
-    getNeighbors(vertexOrId: V | VertexId): V[] {
-        const neighbors: V[] = [];
-        const vertex = this.getVertex(vertexOrId);
-        if (vertex) {
-            const neighborEdges = this.getEdgesOf(vertex);
-            for (const edge of neighborEdges) {
-                const neighbor = this.getVertex(edge.vertices.filter(e => e !== vertex.id)[0]);
-                if (neighbor) {
-                    neighbors.push(neighbor);
-                }
-            }
-        }
-        return neighbors;
-    }
-
-    /**
-     * The function "getEndsOfEdge" returns the vertices at the ends of a given edge, or null if the edge does not exist in
-     * the graph.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
-     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[V, V]` if the edge exists in the
-     * graph and both vertices are found. If the edge does not exist or one or both vertices are not found, it returns
-     * `null`.
-     */
-    getEndsOfEdge(edge: E): [V, V] | null {
-        if (!this.hasEdge(edge.vertices[0], edge.vertices[1])) {
-            return null;
-        }
-        const v1 = this.getVertex(edge.vertices[0]);
-        const v2 = this.getVertex(edge.vertices[1]);
-        if (v1 && v2) {
-            return [v1, v2];
-        } else {
-            return null;
-        }
-    }
-}

package/src/data-structures/hash/coordinate-map.ts

@@ -1,74 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export class CoordinateMap<V> extends Map<any, V> {
-    constructor(joint?: string) {
-        super();
-        if (joint !== undefined) this._joint = joint;
-    }
-
-    protected _joint: string = '_';
-
-    get joint(): string {
-        return this._joint;
-    }
-
-    protected set joint(v: string) {
-        this._joint = v;
-    }
-
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getJoint(): string {
-        return this._joint;
-    }
-
-    /**
-     * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the
-     * key array with a specified delimiter.
-     * @param {number[]} key - The parameter "key" is an array of numbers.
-     * @returns The `has` method is being overridden to return the result of calling the `has` method of the superclass
-     * (`super.has`) with the `key` array joined together using the `_joint` property.
-     */
-    override has(key: number[]) {
-        return super.has(key.join(this._joint));
-    }
-
-    /**
-     * The function overrides the set method of a Map object to convert the key from an array to a string using a specified
-     * delimiter before calling the original set method.
-     * @param {number[]} key - The key parameter is an array of numbers.
-     * @param {V} value - The value parameter is the value that you want to associate with the specified key.
-     * @returns The `set` method is returning the result of calling the `set` method of the superclass
-     * (`super.set(key.join(this._joint), value)`).
-     */
-    override set(key: number[], value: V) {
-        return super.set(key.join(this._joint), value);
-    }
-
-    /**
-     * The function overrides the get method to join the key array with a specified joint and then calls the super get
-     * method.
-     * @param {number[]} key - An array of numbers
-     * @returns The code is returning the value associated with the specified key in the map.
-     */
-    override get(key: number[]) {
-        return super.get(key.join(this._joint));
-    }
-
-    /**
-     * The function overrides the delete method and joins the key array using a specified joint character before calling
-     * the super delete method.
-     * @param {number[]} key - An array of numbers that represents the key to be deleted.
-     * @returns The `delete` method is returning the result of calling the `delete` method on the superclass, with the
-     * `key` array joined together using the `_joint` property.
-     */
-    override delete(key: number[]) {
-        return super.delete(key.join(this._joint));
-    }
-}

package/src/data-structures/hash/coordinate-set.ts

@@ -1,63 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export class CoordinateSet extends Set {
-    constructor(joint?: string) {
-        super();
-        if (joint !== undefined) this._joint = joint;
-    }
-
-    protected _joint: string = '_';
-
-    get joint(): string {
-        return this._joint;
-    }
-
-    protected set joint(v: string) {
-        this._joint = v;
-    }
-
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getJoint(): string {
-        return this._joint;
-    }
-
-    /**
-     * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
-     * joining its elements with a specified separator.
-     * @param {number[]} value - The parameter "value" is an array of numbers.
-     * @returns The overridden `has` method is returning the result of calling the `has` method of the superclass, passing
-     * in the joined value as an argument.
-     */
-    override has(value: number[]) {
-        return super.has(value.join(this._joint));
-    }
-
-    /**
-     * The "add" function overrides the parent class's "add" function by joining the elements of the input array with a
-     * specified delimiter before calling the parent class's "add" function.
-     * @param {number[]} value - An array of numbers
-     * @returns The overridden `add` method is returning the result of calling the `add` method of the superclass
-     * (`super.add`) with the joined string representation of the `value` array (`value.join(this._joint)`).
-     */
-    override add(value: number[]) {
-        return super.add(value.join(this._joint));
-    }
-
-    /**
-     * The function overrides the delete method and deletes an element from a Set by joining the elements of the input
-     * array with a specified joint and then calling the delete method of the parent class.
-     * @param {number[]} value - An array of numbers
-     * @returns The `delete` method is returning the result of calling the `delete` method of the superclass, with the
-     * `value` array joined together using the `_joint` property.
-     */
-    override delete(value: number[]) {
-        return super.delete(value.join(this._joint));
-    }
-}

package/src/data-structures/hash/hash-table.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,6 +0,0 @@
-export * from './hash-table';
-export * from './coordinate-map';
-export * from './coordinate-set';
-export * from './pair';
-export * from './tree-map';
-export * from './tree-set';

package/src/data-structures/hash/pair.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1 +0,0 @@
-export {};

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,162 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import {PriorityQueue} from '../priority-queue';
-import type {HeapItem, HeapOptions} from '../types';
-
-export abstract class Heap<T> {
-    /**
-     * The function is a constructor for a class that initializes a priority callback function based on the
-     * options provided.
-     * @param [options] - An optional object that contains configuration options for the Heap.
-     */
-    protected constructor(options?: HeapOptions<T>) {
-        if (options) {
-            const {priority} = options;
-            if (priority !== undefined && typeof priority !== 'function') {
-                throw new Error('.constructor expects a valid priority function');
-            }
-            this._priorityCb = priority || ((el) => +el);
-        } else {
-            this._priorityCb = (el) => +el;
-        }
-    }
-
-    protected abstract _pq: PriorityQueue<HeapItem<T>>;
-
-    get pq() {
-        return this._pq;
-    }
-
-    protected set pq(v: PriorityQueue<HeapItem<T>>) {
-        this._pq = v;
-    }
-
-    protected _priorityCb: (element: T) => number;
-    get priorityCb() {
-        return this._priorityCb;
-    }
-
-    protected set priorityCb(v: (element: T) => number) {
-        this._priorityCb = v;
-    }
-
-    /**
-     * The function returns the size of a priority queue.
-     * @returns The size of the priority queue.
-     */
-    get size(): number {
-        return this._pq.size;
-    }
-
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getPq() {
-        return this._pq;
-    }
-
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getPriorityCb() {
-        return this._priorityCb;
-    }
-
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getSize(): number {
-        return this._pq.size;
-    }
-
-    /**
-     * The function checks if a priority queue is empty.
-     * @returns {boolean} A boolean value indicating whether the size of the priority queue is less than 1.
-     */
-    isEmpty(): boolean {
-        return this._pq.size < 1;
-    }
-
-    /**
-     * The `peek` function returns the top item in the priority queue without removing it.
-     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an element with the highest priority in the queue
-     */
-    peek(): HeapItem<T> | null {
-        return this._pq.peek();
-    }
-
-    /**
-     * The `peekLast` function returns the last item in the heap.
-     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an element with the lowest priority in the queue
-     */
-    peekLast(): HeapItem<T> | null {
-        return this._pq.leaf();
-    }
-
-    /**
-     * The `add` function adds an element to a priority queue with an optional priority value.
-     * @param {T} element - The `element` parameter represents the value that you want to add to the heap. It can be of any
-     * type.
-     * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
-     * element being added to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
-     * the value of `element`. If the `element` parameter is not a number, then the
-     * @returns The `add` method returns the instance of the `Heap` class.
-     * @throws {Error} if priority is not a valid number
-     */
-    add(element: T, priority?: number): Heap<T> {
-        if (typeof element === 'number') {
-            priority = element;
-        } else {
-            if (priority === undefined) {
-                throw new Error('.add expects a numeric priority');
-            }
-        }
-
-        if (priority && Number.isNaN(+priority)) {
-            throw new Error('.add expects a numeric priority');
-        }
-
-        if (Number.isNaN(+priority) && Number.isNaN(this._priorityCb(element))) {
-            throw new Error(
-                '.add expects a numeric priority '
-                + 'or a constructor callback that returns a number'
-            );
-        }
-
-        const _priority = !Number.isNaN(+priority) ? priority : this._priorityCb(element);
-        this._pq.add({priority: _priority, element});
-        return this;
-    }
-
-    /**
-     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an element with the highest priority in the queue
-     * @returns either a HeapItem<T> object or null.
-     */
-    poll(): HeapItem<T> | null {
-        const top = this._pq.poll();
-        if (!top) {
-            return null;
-        }
-        return top;
-    }
-
-    /**
-     * The `toArray` function returns an array of `HeapItem<T>` objects.
-     * @returns An array of HeapItem<T> objects.Returns a sorted list of elements
-     */
-    toArray(): HeapItem<T>[] {
-        return this._pq.toArray();
-    }
-
-    /**
-     * The clear function clears the priority queue.
-     */
-    clear(): void {
-        this._pq.clear();
-    }
-}

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

@@ -1,3 +0,0 @@
-export * from './max-heap';
-export * from './min-heap';
-export * from './heap';

package/src/data-structures/heap/max-heap.ts

@@ -1,31 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-
-import {Heap} from './heap';
-import {PriorityQueue} from '../priority-queue';
-import type {HeapItem, HeapOptions} from '../types';
-
-/**
- * @class MaxHeap
- * @extends Heap
- */
-export class MaxHeap<T> extends Heap<T> {
-    protected _pq: PriorityQueue<HeapItem<T>>;
-
-    /**
-     * The constructor initializes a PriorityQueue with a custom comparator function.
-     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
-     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
-     */
-    constructor(options?: HeapOptions<T>) {
-        super(options);
-        this._pq = new PriorityQueue<HeapItem<T>>({
-            comparator: (a, b) => b.priority - a.priority
-        });
-    }
-}

package/src/data-structures/heap/min-heap.ts

@@ -1,34 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-
-import {Heap} from './heap';
-import {PriorityQueue} from '../priority-queue';
-import type {HeapItem, HeapOptions} from '../types';
-
-/**
- * @class MinHeap
- * @extends Heap
- */
-export class MinHeap<T> extends Heap<T> {
-    protected _pq: PriorityQueue<HeapItem<T>>;
-
-    /**
-     * The constructor initializes a PriorityQueue with a comparator function that compares the priority of two HeapItem
-     * objects.
-     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
-     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
-     */
-    constructor(options?: HeapOptions<T>) {
-        super(options);
-        this._pq = new PriorityQueue<HeapItem<T>>({
-            comparator: (a, b) => a.priority - b.priority
-        });
-    }
-}
-
-

package/src/data-structures/index.ts

@@ -1,13 +0,0 @@
-export * from './hash';
-export * from './linked-list';
-export * from './stack';
-export * from './queue';
-export * from './graph';
-export * from './binary-tree';
-export * from './heap';
-export * from './priority-queue';
-export * from './matrix';
-export * from './trie';
-export * from './types';
-
-