data-structure-typed 0.9.16 → 1.3.0

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

@@ -1,139 +0,0 @@
-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<T> extends DoublyLinkedList<T> {
-
-}
-
-// 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<T> {
-    protected _nodes: { [key: number]: T } = {};
-    protected _capacity = Number.MAX_SAFE_INTEGER;
-    protected _first: number = -1;
-    protected _last: number = -1;
-    protected _size: number = 0;
-
-    constructor(capacity?: number) {
-        if (capacity !== undefined) this._capacity = capacity;
-    }
-
-    size() {
-        return this._size;
-    }
-
-    offerFirst(value: T) {
-        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++;
-    }
-
-    offerLast(value: T) {
-        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++;
-    }
-
-    pollFirst() {
-        if (!this._size) return;
-        const value = this.peekFirst();
-        delete this._nodes[this._first];
-        this._first++;
-        this._size--;
-        return value;
-    }
-
-    peekFirst() {
-        if (this._size) return this._nodes[this._first];
-    }
-
-    pollLast() {
-        if (!this._size) return;
-        const value = this.peekLast();
-        delete this._nodes[this._last];
-        this._last--;
-        this._size--;
-
-        return value;
-    }
-
-    peekLast() {
-        if (this._size) return this._nodes[this._last];
-    }
-
-    get(index: number) {
-        return this._nodes[this._first + index] || null;
-    }
-
-    isEmpty() {
-        return this._size <= 0;
-    }
-}
-
-// O(1) time complexity of obtaining the value
-// O(n) time complexity of adding at the beginning and the end
-export class ArrayDeque<T> {
-    protected _nodes: T[] = [];
-
-    get size() {
-        return this._nodes.length;
-    }
-
-    offerLast(value: T) {
-        return this._nodes.push(value);
-    }
-
-    pollLast(): T | null {
-        return this._nodes.pop() ?? null;
-    }
-
-    pollFirst(): T | null {
-        return this._nodes.shift() ?? null;
-    }
-
-    offerFirst(value: T) {
-        return this._nodes.unshift(value);
-    }
-
-    peekFirst(): T | null {
-        return this._nodes[0] ?? null;
-    }
-
-    peekLast(): T | null {
-        return this._nodes[this._nodes.length - 1] ?? null;
-    }
-
-    get(index: number): T | null {
-        return this._nodes[index] ?? null;
-    }
-
-    set(index: number, value: T) {
-        return this._nodes[index] = value;
-    }
-
-    insert(index: number, value: T) {
-        return this._nodes.splice(index, 0, value);
-    }
-
-    remove(index: number) {
-        return this._nodes.splice(index, 1);
-    }
-
-    isEmpty() {
-        return this._nodes.length === 0;
-    }
-}

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

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

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

@@ -1,122 +0,0 @@
-/**
- * @license MIT
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
- * @class
- */
-export class Queue<T> {
-    protected _nodes: T[];
-    protected _offset: number;
-
-    /**
-     * Creates a queue.
-     * @param {array} [elements]
-     */
-    constructor(elements?: T[]) {
-        this._nodes = elements || [];
-        this._offset = 0;
-    }
-
-    /**
-     * Creates a queue from an existing array.
-     * @public
-     * @static
-     * @param {array} elements
-     * @return {Queue}
-     */
-    static fromArray<T>(elements: T[]): Queue<T> {
-        return new Queue(elements);
-    }
-
-    /**
-     * Adds an element at the back of the queue.
-     * @public
-     * @param {any} element
-     */
-    offer(element: T): Queue<T> {
-        this._nodes.push(element);
-        return this;
-    }
-
-    /**
-     * Dequeues the front element in the queue.
-     * @public
-     * @returns {any}
-     */
-    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;
-    }
-
-    /**
-     * Returns the front element of the queue.
-     * @public
-     * @returns {any}
-     */
-    peek(): T | null {
-        return this.size() > 0 ? this._nodes[this._offset] : null;
-    }
-
-    /**
-     * Returns the back element of the queue.
-     * @public
-     * @returns {any}
-     */
-    peekLast(): T | null {
-        return this.size() > 0 ? this._nodes[this._nodes.length - 1] : null;
-    }
-
-    /**
-     * Returns the number of elements in the queue.
-     * @public
-     * @returns {number}
-     */
-    size(): number {
-        return this._nodes.length - this._offset;
-    }
-
-    /**
-     * Checks if the queue is empty.
-     * @public
-     * @returns {boolean}
-     */
-    isEmpty(): boolean {
-        return this.size() === 0;
-    }
-
-    /**
-     * Returns the remaining elements in the queue as an array.
-     * @public
-     * @returns {array}
-     */
-    toArray(): T[] {
-        return this._nodes.slice(this._offset);
-    }
-
-    /**
-     * Clears the queue.
-     * @public
-     */
-    clear(): void {
-        this._nodes = [];
-        this._offset = 0;
-    }
-
-    /**
-     * Creates a shallow copy of the queue.
-     * @public
-     * @return {Queue}
-     */
-    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,103 +0,0 @@
-/**
- * @license MIT
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
- * @class
- */
-export class Stack<T> {
-    protected _elements: T[];
-
-    /**
-     * Creates a stack.
-     * @param {array} [elements]
-     */
-    constructor(elements?: T[]) {
-        this._elements = Array.isArray(elements) ? elements : [];
-    }
-
-    /**
-     * Creates a stack from an existing array
-     * @public
-     * @static
-     * @param {array} [elements]
-     * @return {Stack}
-     */
-    static fromArray<T>(elements: T[]): Stack<T> {
-        return new Stack(elements);
-    }
-
-    /**
-     * Checks if the stack is empty.
-     * @public
-     * @returns {boolean}
-     */
-    isEmpty(): boolean {
-        return this._elements.length === 0;
-    }
-
-    /**
-     * Returns the number of elements in the stack.
-     * @public
-     * @returns {number}
-     */
-    size(): number {
-        return this._elements.length;
-    }
-
-    /**
-     * Returns the top element in the stack.
-     * @public
-     * @returns {object}
-     */
-    peek(): T | null {
-        if (this.isEmpty()) return null;
-
-        return this._elements[this._elements.length - 1];
-    }
-
-    /**
-     * Adds an element to the top of the stack.
-     * @public
-     * @param {object} element
-     */
-    push(element: T): Stack<T> {
-        this._elements.push(element);
-        return this;
-    }
-
-    /**
-     * Removes and returns the top element in the stack.
-     * @public
-     * @returns {object}
-     */
-    pop(): T | null {
-        if (this.isEmpty()) return null;
-
-        return this._elements.pop() || null;
-    }
-
-    /**
-     * Returns the remaining elements as an array.
-     * @public
-     * @returns {array}
-     */
-    toArray(): T[] {
-        return this._elements.slice();
-    }
-
-    /**
-     * Clears all elements from the stack.
-     * @public
-     */
-    clear(): void {
-        this._elements = [];
-    }
-
-    /**
-     * Creates a shallow copy from the stack.
-     * @public
-     * @return {Stack}
-     */
-    clone(): Stack<T> {
-        return new Stack(this._elements.slice());
-    }
-}

package/src/data-structures/trampoline.ts

@@ -1,51 +0,0 @@
-export const THUNK_SYMBOL = Symbol('thunk')
-
-export const isThunk = (fnOrValue: any) => {
-    return typeof fnOrValue === 'function' && fnOrValue.__THUNK__ === THUNK_SYMBOL
-}
-
-type ToThunkFn = () => ReturnType<TrlFn>;
-
-type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: typeof THUNK_SYMBOL };
-
-export const toThunk = (fn: ToThunkFn): Thunk => {
-    const thunk = () => fn()
-    thunk.__THUNK__ = THUNK_SYMBOL
-    return thunk
-}
-
-type TrlFn = (...args: any[]) => any;
-export const trampoline = (fn: TrlFn) => {
-    const cont = (...args: [...Parameters<TrlFn>]) => toThunk(() => fn(...args))
-
-    return Object.assign(
-        (...args: [...Parameters<TrlFn>]) => {
-            let result = fn(...args)
-
-            while (isThunk(result) && typeof result === 'function') {
-                result = result()
-            }
-
-            return result
-        },
-        {cont}
-    )
-}
-
-type TrlAsyncFn = (...args: any[]) => any;
-export const trampolineAsync = (fn: TrlAsyncFn) => {
-    const cont = (...args: [...Parameters<TrlAsyncFn>]) => toThunk(() => fn(...args))
-
-    return Object.assign(
-        async (...args: [...Parameters<TrlAsyncFn>]) => {
-            let result = await fn(...args)
-
-            while (isThunk(result) && typeof result === 'function') {
-                result = await result()
-            }
-
-            return result
-        },
-        {cont}
-    )
-}

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

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

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

@@ -1,203 +0,0 @@
-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.put(i);
-            }
-        }
-    }
-
-    protected _root: TrieNode;
-
-    get root() {
-        return this._root;
-    }
-
-    set root(v: TrieNode) {
-        this._root = v;
-    }
-
-    put(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 ---
-    /**
-     * Only can present as a prefix, not a word
-     * @param input
-     */
-    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;
-    }
-
-    /**
-     * Can present as a abs prefix or word
-     * @param input
-     */
-    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;
-    }
-
-    /**
-     * Check if the input string is the common prefix of all the words
-     * @param input
-     */
-    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;
-    }
-
-    // Retrieve the longest common prefix of all the words
-    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;
-    }
-
-    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> {
-
-    containsVertex(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[];
-
-    containsEdge(src: V | VertexId, dest: V | VertexId): boolean;
-
-    // containsEdge(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 };