data-structure-typed 1.15.1 → 1.16.1

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

@@ -1,120 +0,0 @@
-/**
- * @license MIT
- * @copyright Tyler Zeng <zrwusa@gmail.com>
- * @class
- */
-export class Queue<T> {
-    protected _nodes: T[];
-    protected _offset: number;
-
-    /**
-     * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
-     * @param {T[]} [elements] - The `elements` parameter is an optional array of elements of type `T`. 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?: T[]) {
-        this._nodes = elements || [];
-        this._offset = 0;
-    }
-
-    /**
-     * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
-     * @public
-     * @static
-     * @param {T[]} elements - The "elements" parameter is an array of elements of type T.
-     * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
-     * array.
-     */
-    static fromArray<T>(elements: T[]): Queue<T> {
-        return new Queue(elements);
-    }
-
-    /**
-     * The add 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 {T} element - The `element` parameter represents the element that you want to add to the queue.
-     * @returns The `add` method is returning a `Queue<T>` object.
-     */
-    add(element: T): Queue<T> {
-        this._nodes.push(element);
-        return this;
-    }
-
-    /**
-     * The `poll` function removes and returns the first element in the queue, and adjusts the internal data structure if
-     * necessary to optimize performance.
-     * @returns The function `poll()` returns either the first element in the queue or `null` if the queue is empty.
-     */
-    poll(): T | null {
-        if (this.size() === 0) return null;
-
-        const first = this.peek();
-        this._offset += 1;
-
-        if (this._offset * 2 < this._nodes.length) return first;
-
-        // only remove 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(): T | null {
-        return this.size() > 0 ? this._nodes[this._offset] : null;
-    }
-
-    /**
-     * 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(): T | null {
-        return this.size() > 0 ? this._nodes[this._nodes.length - 1] : null;
-    }
-
-    /**
-     * 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.
-     */
-    size(): number {
-        return this._nodes.length - this._offset;
-    }
-
-    /**
-     * 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 T is being returned.
-     */
-    toArray(): T[] {
-        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<T> {
-        return new Queue(this._nodes.slice(this._offset));
-    }
-}

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

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

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

@@ -1,98 +0,0 @@
-/**
- * @license MIT
- * @copyright Tyler Zeng <zrwusa@gmail.com>
- * @class
- */
-export class Stack<T> {
-    protected _elements: T[];
-
-    /**
-     * The constructor initializes an array of elements, which can be provided as an optional parameter.
-     * @param {T[]} [elements] - The `elements` parameter is an optional parameter of type `T[]`, which represents an array
-     * of elements of type `T`. 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?: T[]) {
-        this._elements = Array.isArray(elements) ? elements : [];
-    }
-
-    /**
-     * The function "fromArray" creates a new Stack object from an array of elements.
-     * @param {T[]} elements - The `elements` parameter is an array of elements of type `T`.
-     * @returns {Stack} The method is returning a new instance of the Stack class, initialized with the elements from the input
-     * array.
-     */
-    static fromArray<T>(elements: T[]): Stack<T> {
-        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(): T | 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 {T} element - The parameter "element" is of type T, which means it can be any data type.
-     * @returns The `push` method is returning the updated `Stack<T>` object.
-     */
-    push(element: T): Stack<T> {
-        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(): T | 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 T.
-     */
-    toArray(): T[] {
-        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<T> {
-        return new Stack(this._elements.slice());
-    }
-}

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

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

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

@@ -1,225 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export class TrieNode {
-    protected _value;
-
-    constructor(v: string) {
-        this._value = v;
-        this._isEnd = false;
-        this._children = new Map<string, TrieNode>();
-    }
-
-    protected _children: Map<string, TrieNode>;
-
-    get children(): Map<string, TrieNode> {
-        return this._children;
-    }
-
-    set children(v: Map<string, TrieNode>) {
-        this._children = v;
-    }
-
-    protected _isEnd: boolean;
-
-    get isEnd(): boolean {
-        return this._isEnd;
-    }
-
-    set isEnd(v: boolean) {
-        this._isEnd = v;
-    }
-
-    get val(): string {
-        return this._value;
-    }
-
-    set val(v: string) {
-        this._value = v;
-    }
-}
-
-export class Trie {
-    constructor(words?: string[]) {
-        this._root = new TrieNode('');
-        if (words) {
-            for (const i of words) {
-                this.add(i);
-            }
-        }
-    }
-
-    protected _root: TrieNode;
-
-    get root() {
-        return this._root;
-    }
-
-    set root(v: TrieNode) {
-        this._root = v;
-    }
-
-    add(word: string): boolean {
-        let cur = this._root;
-        for (const c of word) {
-            let nodeC = cur.children.get(c);
-            if (!nodeC) {
-                nodeC = new TrieNode(c);
-                cur.children.set(c, nodeC);
-            }
-            cur = nodeC;
-        }
-        cur.isEnd = true;
-        return true;
-    }
-
-    has(input: string): boolean {
-        let cur = this._root;
-        for (const c of input) {
-            const nodeC = cur.children.get(c);
-            if (!nodeC) return false;
-            cur = nodeC;
-        }
-        return cur.isEnd;
-    }
-
-    remove(word: string) {
-        let isDeleted = false;
-        const dfs = (cur: TrieNode, i: number): boolean => {
-            const char = word[i];
-            const child = cur.children.get(char);
-            if (child) {
-                if (i === word.length - 1) {
-                    if (child.isEnd) {
-                        if (child.children.size > 0) {
-                            child.isEnd = false;
-                        } else {
-                            cur.children.delete(char);
-                        }
-                        isDeleted = true;
-                        return true;
-                    }
-                    return false;
-                }
-                const res = dfs(child, i + 1);
-                if (res && !cur.isEnd && child.children.size === 0) {
-                    cur.children.delete(char);
-                    return true;
-                }
-                return false;
-            }
-            return false;
-        }
-
-        dfs(this.root, 0);
-        return isDeleted;
-    }
-
-    // --- start additional methods ---
-    /**
-     * The function checks if a given input string has an absolute prefix in a tree data structure.Only can present as a prefix, not a word
-     * @param {string} input - The input parameter is a string that represents the input value for the function.
-     * @returns a boolean value.
-     */
-    isAbsPrefix(input: string): boolean {
-        let cur = this._root;
-        for (const c of input) {
-            const nodeC = cur.children.get(c);
-            if (!nodeC) return false;
-            cur = nodeC;
-        }
-        return !cur.isEnd;
-    }
-
-    /**
-     * The function checks if a given input string is a prefix of any existing string in a tree structure.Can present as a abs prefix or word
-     * @param {string} input - The input parameter is a string that represents the prefix we want to check.
-     * @returns a boolean value.
-     */
-    isPrefix(input: string): boolean {
-        let cur = this._root;
-        for (const c of input) {
-            const nodeC = cur.children.get(c);
-            if (!nodeC) return false;
-            cur = nodeC;
-        }
-        return true;
-    }
-
-    /**
-     * The function checks if the input string is a common prefix in a Trie data structure.Check if the input string is the common prefix of all the words
-     * @param {string} input - The input parameter is a string that represents the common prefix that we want to check for
-     * in the Trie data structure.
-     * @returns a boolean value indicating whether the input string is a common prefix in the Trie data structure.
-     */
-    isCommonPrefix(input: string): boolean {
-        let commonPre = '';
-        const dfs = (cur: TrieNode) => {
-            commonPre += cur.val;
-            if (commonPre === input) return;
-            if (cur.isEnd) return;
-            if (cur && cur.children && cur.children.size === 1) dfs(Array.from(cur.children.values())[0]);
-            else return;
-        }
-        dfs(this._root);
-        return commonPre === input;
-    }
-
-    /**
-     * The function `getLongestCommonPrefix` returns the longest common prefix among all the words stored in a Trie data
-     * structure.
-     * @returns The function `getLongestCommonPrefix` returns a string, which is the longest common prefix found in the
-     * Trie.
-     */
-    getLongestCommonPrefix(): string {
-        let commonPre = '';
-        const dfs = (cur: TrieNode) => {
-            commonPre += cur.val;
-            if (cur.isEnd) return;
-            if (cur && cur.children && cur.children.size === 1) dfs(Array.from(cur.children.values())[0]);
-            else return;
-        }
-        dfs(this._root);
-        return commonPre;
-    }
-
-    /**
-     * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
-     * @param [prefix] - The `prefix` parameter is a string that represents the prefix that we want to search for in the
-     * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
-     * @returns an array of strings.
-     */
-    getAll(prefix = ''): string[] {
-        const words: string[] = [];
-
-        function dfs(node: TrieNode, word: string) {
-            for (const char of node.children.keys()) {
-                const charNode = node.children.get(char);
-                if (charNode !== undefined) {
-                    dfs(charNode, word.concat(char));
-                }
-            }
-            if (node.isEnd) {
-                words.push(word);
-            }
-        }
-
-        let startNode = this._root;
-
-        if (prefix) {
-            for (const c of prefix) {
-                const nodeC = startNode.children.get(c);
-                if (nodeC) startNode = nodeC;
-            }
-        }
-
-        dfs(startNode, prefix);
-        return words;
-    }
-
-    // --- end additional methods ---
-}

package/src/data-structures/types/abstract-graph.ts

@@ -1,51 +0,0 @@
-export type VertexId = string | number;
-export type DijkstraResult<V> =
-    { distMap: Map<V, number>, preMap: Map<V, V | null>, seen: Set<V>, paths: V[][], minDist: number, minPath: V[] }
-    | null;
-
-export interface IGraph<V, E> {
-
-    hasVertex(vertexOrId: V | VertexId): boolean;
-
-    getVertex(vertexOrId: VertexId | V): V | null;
-
-    getVertexId(vertexOrId: V | VertexId): VertexId;
-
-    vertexSet(): Map<VertexId, V>;
-
-    addVertex(v: V): boolean;
-
-    removeVertex(vertexOrId: V | VertexId): boolean;
-
-    removeAllVertices(vertices: V[] | VertexId[]): boolean;
-
-    degreeOf(vertexOrId: V | VertexId): number;
-
-    edgesOf(vertexOrId: V | VertexId): E[];
-
-    hasEdge(src: V | VertexId, dest: V | VertexId): boolean;
-
-    // hasEdge(e: E): boolean;
-
-    getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
-
-    // getAllEdges(src: V, dest: V): E[];
-
-    edgeSet(): E[];
-
-    addEdge(edge: E): boolean;
-
-    removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
-
-    removeEdge(edge: E): E | null;
-
-    // removeAllEdges(v1: VertexId | V, v2: VertexId | V): (E | null)[];
-
-    // removeAllEdges(edges: E[] | [VertexId, VertexId]): boolean;
-
-    setEdgeWeight(srcOrId: V | VertexId, destOrId: V | VertexId, weight: number): boolean;
-
-    getMinPathBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): V[] | null;
-
-    getNeighbors(vertexOrId: V | VertexId): V[];
-}

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

@@ -1,6 +0,0 @@
-import {AVLTreeNode} from '../binary-tree';
-
-export interface AVLTreeDeleted<T> {
-    deleted: AVLTreeNode<T> | null;
-    needBalanced: AVLTreeNode<T> | null;
-}

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

@@ -1,15 +0,0 @@
-import {BinaryTreeNode} from '../binary-tree';
-
-export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
-export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
-export type DFSOrderPattern = 'in' | 'pre' | 'post';
-export type BinaryTreeNodeId = number;
-export type BinaryTreeDeleted<T> = { deleted: BinaryTreeNode<T> | null | undefined, needBalanced: BinaryTreeNode<T> | null };
-export type ResultByProperty<T> = T | BinaryTreeNode<T> | number | BinaryTreeNodeId;
-export type ResultsByProperty<T> = ResultByProperty<T>[];
-
-export interface BinaryTreeNodeObj<T> {
-    id: BinaryTreeNodeId;
-    val: T;
-    count?: number;
-}

package/src/data-structures/types/bst.ts

@@ -1,5 +0,0 @@
-import {BSTNode} from '../binary-tree';
-import type {BinaryTreeNodeId} from './binary-tree';
-
-export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
-export type BSTDeletedResult<T> = { deleted: BSTNode<T> | null, needBalanced: BSTNode<T> | null };

package/src/data-structures/types/directed-graph.ts

@@ -1,18 +0,0 @@
-import {VertexId} from './abstract-graph';
-
-export interface IDirectedGraph<V, E> {
-    incomingEdgesOf(vertex: V): E[];
-
-    outgoingEdgesOf(vertex: V): E[];
-
-    inDegreeOf(vertexOrId: V | VertexId): number;
-
-    outDegreeOf(vertexOrId: V | VertexId): number;
-
-    getEdgeSrc(e: E): V | null;
-
-    getEdgeDest(e: E): V | null;
-}
-
-// 0 means unknown, 1 means visiting, 2 means visited;
-export type TopologicalStatus = 0 | 1 | 2;

package/src/data-structures/types/doubly-linked-list.ts

@@ -1 +0,0 @@
-export type DoublyLinkedListGetBy = 'node' | 'val';

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

@@ -1,8 +0,0 @@
-export interface HeapOptions<T> {
-    priority?: (element: T) => number;
-}
-
-export interface HeapItem<T> {
-    priority: number;
-    element: T | null;
-}

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

@@ -1,13 +0,0 @@
-export * from './binary-tree';
-export * from './bst';
-export * from './avl-tree';
-export * from './segment-tree';
-export * from './tree-multiset';
-export * from './abstract-graph';
-export * from './directed-graph';
-export * from './priority-queue';
-export * from './heap';
-export * from './singly-linked-list';
-export * from './doubly-linked-list';
-export * from './navigator';
-export * from '../../utils/types/utils';

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

@@ -1,13 +0,0 @@
-export type Direction = 'up' | 'right' | 'down' | 'left';
-export type Turning = { [key in Direction]: Direction };
-
-export interface NavigatorParams<T> {
-    matrix: T[][],
-    turning: Turning,
-    onMove: (cur: [number, number]) => void
-    init: {
-        cur: [number, number],
-        charDir: Direction,
-        VISITED: T,
-    }
-}

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

@@ -1,9 +0,0 @@
-export type PriorityQueueComparator<T> = (a: T, b: T) => number;
-
-export interface PriorityQueueOptions<T> {
-    nodes?: T[];
-    isFix?: boolean;
-    comparator: PriorityQueueComparator<T>;
-}
-
-export type PriorityQueueDFSOrderPattern = 'pre' | 'in' | 'post';

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

@@ -1 +0,0 @@
-export type SegmentTreeNodeVal = number;

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

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

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

@@ -1,3 +0,0 @@
-import {BSTNode} from '../binary-tree';
-
-export type TreeMultiSetDeletedResult<T> = { deleted: BSTNode<T> | null, needBalanced: BSTNode<T> | null };

package/src/index.ts

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

package/src/utils/index.ts

@@ -1,2 +0,0 @@
-export * from './utils';
-export * from './types';

package/src/utils/types/index.ts

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