data-structure-typed 0.9.16 → 1.12.9

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

@@ -1,3 +1,7 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 export class TrieNode {
     protected _value;
 
@@ -114,8 +118,9 @@ export class Trie {
 
     // --- start additional methods ---
     /**
-     * Only can present as a prefix, not a word
-     * @param input
+     * 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;
@@ -128,8 +133,9 @@ export class Trie {
     }
 
     /**
-     * Can present as a abs prefix or word
-     * @param input
+     * 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;
@@ -142,8 +148,10 @@ export class Trie {
     }
 
     /**
-     * Check if the input string is the common prefix of all the words
-     * @param input
+     * 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 = '';
@@ -158,7 +166,12 @@ export class Trie {
         return commonPre === input;
     }
 
-    // Retrieve the longest common prefix of all the words
+    /**
+     * 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) => {
@@ -171,6 +184,12 @@ export class Trie {
         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[] = [];
 

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

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

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

@@ -1,4 +1,4 @@
-import { BinaryTreeNode } from "../binary-tree";
+import {BinaryTreeNode} from '../binary-tree';
 
 export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
 export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;

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

@@ -1,4 +1,4 @@
-import { BSTNode } from '../binary-tree';
+import {BSTNode} from '../binary-tree';
 import type {BinaryTreeNodeId} from './binary-tree';
 
 export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;

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

@@ -10,4 +10,4 @@ export * from './heap';
 export * from './singly-linked-list';
 export * from './doubly-linked-list';
 export * from './navigator';
-export * from './utils';
+export * from '../../utils/types/utils';

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

@@ -1,5 +1,6 @@
 export type Direction = 'up' | 'right' | 'down' | 'left';
 export type Turning = { [key in Direction]: Direction };
+
 export interface NavigatorParams<T> {
     matrix: T[][],
     turning: Turning,

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

@@ -1,15 +1 @@
-import { SinglyLinkedList } from "../linked-list";
-
-/** Type used for filter and find methods, returning a boolean */
-export type TTestFunction<NodeData> = (
-    data: NodeData,
-    index: number,
-    list: SinglyLinkedList<NodeData>,
-) => boolean;
-
-/** Type used for map and forEach methods, returning anything */
-export type TMapFunction<NodeData> = (
-    data: any,
-    index: number,
-    list: SinglyLinkedList<NodeData>,
-) => any;
+export {}

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

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

package/src/{data-structures → utils}/trampoline.ts

@@ -1,20 +1,21 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+import {Thunk, ToThunkFn, TrlAsyncFn, TrlFn} from './types';
+
 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))
 
@@ -32,7 +33,6 @@ export const trampoline = (fn: TrlFn) => {
     )
 }
 
-type TrlAsyncFn = (...args: any[]) => any;
 export const trampolineAsync = (fn: TrlAsyncFn) => {
     const cont = (...args: [...Parameters<TrlAsyncFn>]) => toThunk(() => fn(...args))
 

package/src/utils/types/index.ts

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

package/src/{data-structures → utils}/types/utils.ts

@@ -171,3 +171,10 @@ export type CurryFunc<T> = T extends (...args: infer Args) => infer R
         : R
     : T;
 
+
+export type ToThunkFn = () => ReturnType<TrlFn>;
+const THUNK_SYMBOL = Symbol('thunk')
+export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: typeof THUNK_SYMBOL };
+export type TrlFn = (...args: any[]) => any;
+export type TrlAsyncFn = (...args: any[]) => any;
+

package/src/utils/utils.ts

@@ -1,5 +1,5 @@
 import * as _ from 'lodash';
-import {AnyFunction} from '../data-structures/types';
+import {AnyFunction} from './types';
 
 export type JSONSerializable = {
     [key: string]: any
@@ -323,7 +323,17 @@ export class StringUtil {
     }
 }
 
-export type CaseType = 'camel' | 'snake' | 'pascal' | 'constant' | 'kebab' | 'lower' | 'title' | 'sentence' | 'path' | 'dot';
+export type CaseType =
+    'camel'
+    | 'snake'
+    | 'pascal'
+    | 'constant'
+    | 'kebab'
+    | 'lower'
+    | 'title'
+    | 'sentence'
+    | 'path'
+    | 'dot';
 export const deepKeysConvert = (obj: any, toType?: CaseType): any => {
     const _toType = toType || 'snake';
     if (Array.isArray(obj)) {

package/tests/unit/data-structures/binary-tree/bst.test.ts

@@ -0,0 +1,185 @@
+import {BST, BSTNode} from '../../../../src';
+
+describe('bst-case6', () => {
+    it('should perform various operations on a Binary Search Tree', () => {
+        const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+
+        const tree = new BST();
+
+        expect(tree).toBeInstanceOf(BST);
+
+        for (const i of arr) tree.put(i, i);
+
+        expect(tree.root).toBeInstanceOf(BSTNode);
+        if (tree.root) expect(tree.root.id).toBe(11);
+        expect(tree.count).toBe(16);
+        expect(tree.has(6)).toBe(true);
+
+        const node6 = tree.get(6);
+        expect(node6 && tree.getHeight(node6)).toBe(2);
+        expect(node6 && tree.getDepth(node6)).toBe(3);
+        const getNodeById = tree.get(10, 'id');
+        expect(getNodeById?.id).toBe(10);
+
+        const getNodesByCount = tree.getNodes(1, 'count');
+        expect(getNodesByCount.length).toBe(16);
+
+        const getMinNodeByRoot = tree.getLeftMost();
+        expect(getMinNodeByRoot?.id).toBe(1);
+
+        const node15 = tree.get(15);
+        const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
+        expect(getMinNodeBySpecificNode?.id).toBe(12);
+
+        const subTreeSum = node15 && tree.subTreeSum(node15);
+        expect(subTreeSum).toBe(70);
+
+        const lesserSum = tree.lesserSum(10);
+        expect(lesserSum).toBe(45);
+
+        expect(node15).toBeInstanceOf(BSTNode);
+        if (node15 instanceof BSTNode) {
+            const subTreeAdd = tree.subTreeAdd(node15, 1, 'count');
+            expect(subTreeAdd).toBeDefined();
+        }
+
+
+        const node11 = tree.get(11);
+        expect(node11).toBeInstanceOf(BSTNode);
+        if (node11 instanceof BSTNode) {
+            const allGreaterNodesAdd = tree.allGreaterNodesAdd(node11, 2, 'count');
+            expect(allGreaterNodesAdd).toBeDefined();
+        }
+
+        const dfs = tree.DFS('in', 'node');
+        expect(dfs[0].id).toBe(1);
+        expect(dfs[dfs.length - 1].id).toBe(16);
+
+        tree.balance();
+        const bfs = tree.BFS('node');
+        expect(tree.isBalanced()).toBe(true);
+        expect(bfs[0].id).toBe(8);
+        expect(bfs[bfs.length - 1].id).toBe(16);
+
+        const removed11 = tree.remove(11, true);
+        expect(removed11).toBeInstanceOf(Array);
+        expect(removed11[0]).toBeDefined();
+        expect(removed11[0].deleted).toBeDefined();
+        if (removed11[0].deleted) expect(removed11[0].deleted.id).toBe(11);
+        expect(tree.isAVLBalanced()).toBe(true);
+        expect(node15 && tree.getHeight(node15)).toBe(2);
+
+        const removed1 = tree.remove(1, true);
+        expect(removed1).toBeInstanceOf(Array);
+        expect(removed1[0]).toBeDefined();
+        expect(removed1[0].deleted).toBeDefined();
+        if (removed1[0].deleted) expect(removed1[0].deleted.id).toBe(1);
+
+        expect(tree.isAVLBalanced()).toBe(true);
+        expect(tree.getHeight()).toBe(4);
+
+        const removed4 = tree.remove(4, true);
+        expect(removed4).toBeInstanceOf(Array);
+        expect(removed4[0]).toBeDefined();
+        expect(removed4[0].deleted).toBeDefined();
+        if (removed4[0].deleted) expect(removed4[0].deleted.id).toBe(4);
+        expect(tree.isAVLBalanced()).toBe(true);
+        expect(tree.getHeight()).toBe(4);
+
+        const removed10 = tree.remove(10, true);
+        expect(removed10).toBeInstanceOf(Array);
+        expect(removed10[0]).toBeDefined();
+        expect(removed10[0].deleted).toBeDefined();
+        if (removed10[0].deleted) expect(removed10[0].deleted.id).toBe(10);
+        expect(tree.isAVLBalanced()).toBe(false);
+        expect(tree.getHeight()).toBe(4);
+
+        const removed15 = tree.remove(15, true);
+        expect(removed15).toBeInstanceOf(Array);
+        expect(removed15[0]).toBeDefined();
+        expect(removed15[0].deleted).toBeDefined();
+        if (removed15[0].deleted) expect(removed15[0].deleted.id).toBe(15);
+
+        expect(tree.isAVLBalanced()).toBe(true);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed5 = tree.remove(5, true);
+        expect(removed5).toBeInstanceOf(Array);
+        expect(removed5[0]).toBeDefined();
+        expect(removed5[0].deleted).toBeDefined();
+        if (removed5[0].deleted) expect(removed5[0].deleted.id).toBe(5);
+
+        expect(tree.isAVLBalanced()).toBe(true);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed13 = tree.remove(13, true);
+        expect(removed13).toBeInstanceOf(Array);
+        expect(removed13[0]).toBeDefined();
+        expect(removed13[0].deleted).toBeDefined();
+        if (removed13[0].deleted) expect(removed13[0].deleted.id).toBe(13);
+        expect(tree.isAVLBalanced()).toBe(true);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed3 = tree.remove(3, true);
+        expect(removed3).toBeInstanceOf(Array);
+        expect(removed3[0]).toBeDefined();
+        expect(removed3[0].deleted).toBeDefined();
+        if (removed3[0].deleted) expect(removed3[0].deleted.id).toBe(3);
+        expect(tree.isAVLBalanced()).toBe(false);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed8 = tree.remove(8, true);
+        expect(removed8).toBeInstanceOf(Array);
+        expect(removed8[0]).toBeDefined();
+        expect(removed8[0].deleted).toBeDefined();
+        if (removed8[0].deleted) expect(removed8[0].deleted.id).toBe(8);
+        expect(tree.isAVLBalanced()).toBe(true);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed6 = tree.remove(6, true);
+        expect(removed6).toBeInstanceOf(Array);
+        expect(removed6[0]).toBeDefined();
+        expect(removed6[0].deleted).toBeDefined();
+        if (removed6[0].deleted) expect(removed6[0].deleted.id).toBe(6);
+        expect(tree.remove(6, true).length).toBe(0);
+        expect(tree.isAVLBalanced()).toBe(false);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed7 = tree.remove(7, true);
+        expect(removed7).toBeInstanceOf(Array);
+        expect(removed7[0]).toBeDefined();
+        expect(removed7[0].deleted).toBeDefined();
+        if (removed7[0].deleted) expect(removed7[0].deleted.id).toBe(7);
+        expect(tree.isAVLBalanced()).toBe(false);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed9 = tree.remove(9, true);
+        expect(removed9).toBeInstanceOf(Array);
+        expect(removed9[0]).toBeDefined();
+        expect(removed9[0].deleted).toBeDefined();
+        if (removed9[0].deleted) expect(removed9[0].deleted.id).toBe(9);
+        expect(tree.isAVLBalanced()).toBe(false);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed14 = tree.remove(14, true);
+        expect(removed14).toBeInstanceOf(Array);
+        expect(removed14[0]).toBeDefined();
+        expect(removed14[0].deleted).toBeDefined();
+        if (removed14[0].deleted) expect(removed14[0].deleted.id).toBe(14);
+        expect(tree.isAVLBalanced()).toBe(false);
+        expect(tree.getHeight()).toBe(2);
+
+
+        expect(!tree.isAVLBalanced()).toBe(true);
+
+        const lastBFSIds = tree.BFS();
+        expect(lastBFSIds[0]).toBe(2);
+        expect(lastBFSIds[1]).toBe(12);
+        expect(lastBFSIds[2]).toBe(16);
+
+        const lastBFSNodes = tree.BFS('node');
+        expect(lastBFSNodes[0].id).toBe(2);
+        expect(lastBFSNodes[1].id).toBe(12);
+        expect(lastBFSNodes[2].id).toBe(16);
+    });
+});

package/tests/unit/data-structures/graph/directed-graph.test.ts

@@ -0,0 +1,71 @@
+import { DirectedGraph, DirectedVertex, DirectedEdge } from '../../../../src';
+
+describe('DirectedGraph', () => {
+    let graph: DirectedGraph<DirectedVertex, DirectedEdge>;
+
+    beforeEach(() => {
+        graph = new DirectedGraph();
+    });
+
+    it('should add vertices', () => {
+        const vertex1 = new DirectedVertex('A');
+        const vertex2 = new DirectedVertex('B');
+
+        graph.addVertex(vertex1);
+        graph.addVertex(vertex2);
+
+        expect(graph.containsVertex(vertex1)).toBe(true);
+        expect(graph.containsVertex(vertex2)).toBe(true);
+    });
+
+    it('should add edges', () => {
+        const vertex1 = new DirectedVertex('A');
+        const vertex2 = new DirectedVertex('B');
+        const edge = new DirectedEdge('A', 'B');
+
+        graph.addVertex(vertex1);
+        graph.addVertex(vertex2);
+        graph.addEdge(edge);
+
+        expect(graph.containsEdge('A', 'B')).toBe(true);
+        expect(graph.containsEdge('B', 'A')).toBe(false);
+    });
+
+    it('should remove edges', () => {
+        const vertex1 = new DirectedVertex('A');
+        const vertex2 = new DirectedVertex('B');
+        const edge = new DirectedEdge('A', 'B');
+
+        graph.addVertex(vertex1);
+        graph.addVertex(vertex2);
+        graph.addEdge(edge);
+
+        expect(graph.removeEdge(edge)).toBe(edge);
+        expect(graph.containsEdge('A', 'B')).toBe(false);
+    });
+
+    // Add more test cases for other methods...
+
+    it('should perform topological sort', () => {
+        // Create a graph with vertices and edges
+        const vertexA = new DirectedVertex('A');
+        const vertexB = new DirectedVertex('B');
+        const vertexC = new DirectedVertex('C');
+        const edgeAB = new DirectedEdge('A', 'B');
+        const edgeBC = new DirectedEdge('B', 'C');
+
+        graph.addVertex(vertexA);
+        graph.addVertex(vertexB);
+        graph.addVertex(vertexC);
+        graph.addEdge(edgeAB);
+        graph.addEdge(edgeBC);
+
+        // Perform topological sort
+        const topologicalOrder = graph.topologicalSort();
+
+        if (topologicalOrder) expect(topologicalOrder.map(v => v.id)).toEqual(['A', 'B', 'C']);
+
+    });
+
+    // Add more test cases for other methods...
+});

package/tests/unit/data-structures/graph/index.ts

@@ -0,0 +1,3 @@
+export * from './abstract-graph';
+export * from './directed-graph.test';
+export * from './undirected-graph';