data-structure-typed 1.19.3 → 1.19.5

package/src/data-structures/index.ts

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

package/src/data-structures/interfaces/abstract-binary-tree.ts

@@ -0,0 +1,231 @@
+import {
+    AbstractBinaryTreeNodeProperties,
+    AbstractBinaryTreeNodeProperty,
+    BinaryTreeDeletedResult,
+    BinaryTreeNodeId,
+    BinaryTreeNodePropertyName,
+    DFSOrderPattern,
+    FamilyPosition,
+    LoopType,
+    NodeOrPropertyName
+} from '../types';
+import {AbstractBinaryTreeNode} from '../binary-tree';
+
+export interface IAbstractBinaryTreeNode<T, NEIGHBOR extends IAbstractBinaryTreeNode<T, NEIGHBOR>> {
+
+    get id(): BinaryTreeNodeId
+
+    set id(v: BinaryTreeNodeId)
+
+    get val(): T | undefined
+
+    set val(v: T | undefined)
+
+    get left(): NEIGHBOR | null | undefined
+
+    set left(v: NEIGHBOR | null | undefined)
+
+    get right(): NEIGHBOR | null | undefined
+
+    set right(v: NEIGHBOR | null | undefined)
+
+    get parent(): NEIGHBOR | null | undefined
+
+    set parent(v: NEIGHBOR | null | undefined)
+
+    get familyPosition(): FamilyPosition
+
+    get height(): number
+
+    set height(v: number)
+}
+
+export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'], N>> {
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null
+
+    get loopType(): LoopType
+
+    get visitedId(): BinaryTreeNodeId[]
+
+    get visitedVal(): Array<N['val']>
+
+    get visitedNode(): N[]
+
+    get visitedCount(): number[]
+
+    get visitedLeftSum(): number[]
+
+    get autoIncrementId(): boolean
+
+    get maxId(): number
+
+    get isMergeDuplicatedVal(): boolean
+
+    get root(): N | null
+
+    get size(): number
+
+    swapLocation(srcNode: N, destNode: N): N
+
+    clear(): void
+
+    isEmpty(): boolean
+
+    add(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null | undefined
+
+    addTo(newNode: N | null, parent: N): N | null | undefined
+
+    addMany(data: N[] | Array<N['val']>): (N | null | undefined)[]
+
+    fill(data: N[] | Array<N['val']>): boolean
+
+    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[]
+
+    getDepth(node: N): number
+
+    getHeight(beginRoot?: N | null): number
+
+    getMinHeight(beginRoot?: N | null): number
+
+    isPerfectlyBalanced(beginRoot?: N | null): boolean
+
+    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName ?: BinaryTreeNodePropertyName, onlyOne ?: boolean): N[]
+
+    has(nodeProperty: BinaryTreeNodeId | N, propertyName ?: BinaryTreeNodePropertyName): boolean
+
+    get(nodeProperty: BinaryTreeNodeId | N, propertyName ?: BinaryTreeNodePropertyName): N | null
+
+    getPathToRoot(node: N): N[]
+
+    getLeftMost(): N | null;
+
+    getLeftMost(node: N): N;
+
+    getLeftMost(node?: N | null): N | null
+
+    getRightMost(): N | null;
+
+    getRightMost(node: N): N;
+
+    getRightMost(node?: N | null): N | null
+
+    isBSTByRooted(node: N | null): boolean
+
+    isBST(node?: N | null): boolean
+
+    getSubTreeSize(subTreeRoot: N | null | undefined): number
+
+    // --- start additional methods ---
+
+    subTreeSum(subTreeRoot: N, propertyName ?: BinaryTreeNodePropertyName): number
+
+    subTreeAdd(subTreeRoot: N, delta: number, propertyName ?: BinaryTreeNodePropertyName): boolean
+
+    BFS(): BinaryTreeNodeId[];
+
+    BFS(nodeOrPropertyName: 'id'): BinaryTreeNodeId[];
+
+    BFS(nodeOrPropertyName: 'val'): N['val'][];
+
+    BFS(nodeOrPropertyName: 'node'): N[];
+
+    BFS(nodeOrPropertyName: 'count'): number[];
+
+    BFS(nodeOrPropertyName ?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>
+
+    DFS(): BinaryTreeNodeId[];
+
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+
+    DFS(pattern ?: 'in' | 'pre' | 'post', nodeOrPropertyName ?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>
+
+    DFSIterative(): BinaryTreeNodeId[];
+
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+
+    DFSIterative(pattern ?: 'in' | 'pre' | 'post', nodeOrPropertyName ?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>
+
+    levelIterative(node: N | null): BinaryTreeNodeId[];
+
+    levelIterative(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+
+    levelIterative(node: N | null, nodeOrPropertyName?: 'val'): N['val'][];
+
+    levelIterative(node: N | null, nodeOrPropertyName?: 'node'): N[];
+
+    levelIterative(node: N | null, nodeOrPropertyName?: 'count'): number[];
+
+    levelIterative(node: N | null, nodeOrPropertyName ?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>
+
+    listLevels(node: N | null): BinaryTreeNodeId[][];
+
+    listLevels(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[][];
+
+    listLevels(node: N | null, nodeOrPropertyName?: 'val'): N['val'][][];
+
+    listLevels(node: N | null, nodeOrPropertyName?: 'node'): N[][];
+
+    listLevels(node: N | null, nodeOrPropertyName?: 'count'): number[][];
+
+    listLevels(node: N | null, nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperty<N>[][]
+
+    getPredecessor(node: N): N
+
+    morris(): BinaryTreeNodeId[];
+
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+
+    morris(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>
+
+    // _setLoopType(value: LoopType): void
+    //
+    // _setVisitedId(value: BinaryTreeNodeId[]): void
+    //
+    // _setVisitedVal(value: Array<N>): void
+    //
+    // _setVisitedNode(value: N[]): void
+    //
+    // setVisitedCount(value: number[]): void
+    //
+    // _setVisitedLeftSum(value: number[]): void
+    //
+    // _setAutoIncrementId(value: boolean): void
+    //
+    // _setMaxId(value: number): void
+    //
+    // _setIsDuplicatedVal(value: boolean): void
+    //
+    // _setRoot(v: N | null): void
+    //
+    // _setSize(v: number): void
+    //
+    // _setCount(v: number): void
+    //
+    // _resetResults(): void
+
+    // _pushByPropertyNameStopOrNot(cur: N, result: (N | null | undefined)[], nodeProperty: BinaryTreeNodeId | N, propertyName ?: BinaryTreeNodePropertyName, onlyOne ?: boolean): void
+    //
+    // _accumulatedByPropertyName(node: N, nodeOrPropertyName ?: NodeOrPropertyName): void
+    //
+    // _getResultByPropertyName(nodeOrPropertyName ?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>
+
+    // --- end additional methods ---
+}

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

@@ -0,0 +1,40 @@
+import {VertexId} from '../types';
+
+export interface IAbstractGraph<V, E> {
+
+    hasVertex(vertexOrId: V | VertexId): boolean;
+
+    // _getVertex(vertexOrId: VertexId | V): V | null;
+
+    // _getVertexId(vertexOrId: V | VertexId): VertexId;
+
+    addVertex(id: VertexId, val?: V): boolean;
+
+    // _addVertexOnly(newVertex: 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;
+
+    getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+
+    edgeSet(): E[];
+
+    addEdge(src: V | VertexId, dest: V | VertexId, weight: number, val: E): boolean;
+
+    // _addEdgeOnly(edge: E): boolean;
+
+    removeEdge(edge: E): E | null;
+
+    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/interfaces/avl-tree.ts

@@ -0,0 +1,28 @@
+import {AVLTreeNode} from '../binary-tree';
+import {IBST, IBSTNode} from './bst';
+import {BinaryTreeDeletedResult, BinaryTreeNodeId} from '../types';
+
+export interface IAVLTreeNode<T, NEIGHBOR extends IAVLTreeNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
+
+}
+
+export interface IAVLTree<N extends AVLTreeNode<N['val'], N>> extends IBST<N> {
+
+    add(id: BinaryTreeNodeId, val?: N['val'] | null): N | null | undefined
+
+    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): BinaryTreeDeletedResult<N>[]
+
+    balanceFactor(node: N): number
+
+    updateHeight(node: N): void
+
+    balancePath(node: N): void
+
+    balanceLL(A: N): void
+
+    balanceLR(A: N): void
+
+    balanceRR(A: N): void
+
+    balanceRL(A: N): void
+}

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

@@ -0,0 +1,8 @@
+import {BinaryTreeNode} from '../binary-tree';
+import {IAbstractBinaryTree, IAbstractBinaryTreeNode} from './abstract-binary-tree';
+
+export interface IBinaryTreeNode<T, NEIGHBOR extends IBinaryTreeNode<T, NEIGHBOR>> extends IAbstractBinaryTreeNode<T, NEIGHBOR> {
+}
+
+export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> extends IAbstractBinaryTree<N> {
+}

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

@@ -0,0 +1,32 @@
+import {BSTNode} from '../binary-tree';
+import {IBinaryTree, IBinaryTreeNode} from './binary-tree';
+import {BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName} from '../types';
+
+export interface IBSTNode<T, NEIGHBOR extends IBSTNode<T, NEIGHBOR>> extends IBinaryTreeNode<T, NEIGHBOR> {
+}
+
+export interface IBST<N extends BSTNode<N['val'], N>> extends IBinaryTree<N> {
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N
+
+    add(id: BinaryTreeNodeId, val?: N['val'] | null, count?: number): N | null | undefined
+
+    get(nodeProperty: BinaryTreeNodeId | N, propertyName ?: BinaryTreeNodePropertyName): N | null
+
+    lastKey(): BinaryTreeNodeId
+
+    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[]
+
+    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName ?: BinaryTreeNodePropertyName, onlyOne ?: boolean): N[]
+
+    // --- start additional functions
+
+    lesserSum(id: BinaryTreeNodeId, propertyName ?: BinaryTreeNodePropertyName): number
+
+    allGreaterNodesAdd(node: N, delta: number, propertyName ?: BinaryTreeNodePropertyName): boolean
+
+    perfectlyBalance(): boolean
+
+    isAVLBalanced(): boolean
+
+    // --- end additional functions
+}

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

@@ -0,0 +1,20 @@
+import {VertexId} from '../types';
+import {IAbstractGraph} from './abstract-graph';
+
+export interface IDirectedGraph<V, E> extends IAbstractGraph<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;
+
+    removeEdgeSrcToDest(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+
+    removeEdgesBetween(v1: V | VertexId, v2: V | VertexId): E[];
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,11 @@
+import {RBTreeNode} from '../binary-tree';
+import {IBST, IBSTNode} from './bst';
+import {BinaryTreeNodeId} from '../types';
+
+export interface IRBTreeNode<T, NEIGHBOR extends IRBTreeNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
+}
+
+export interface IRBTree<N extends RBTreeNode<N['val'], N>> extends IBST<N> {
+
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N
+}

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

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

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

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

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

@@ -0,0 +1,12 @@
+import {TreeMultisetNode} from '../binary-tree';
+import {IBSTNode} from './bst';
+import {IAVLTree} from './avl-tree';
+
+export interface ITreeMultisetNode<T, NEIGHBOR extends ITreeMultisetNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
+
+}
+
+export interface ITreeMultiset<N extends TreeMultisetNode<N['val'], N>> extends IAVLTree<N> {
+
+
+}

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

@@ -0,0 +1,6 @@
+import {VertexId} from '../types';
+import {IAbstractGraph} from './abstract-graph';
+
+export interface IUNDirectedGraph<V, E> extends IAbstractGraph<V, E> {
+    removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): E | null;
+}