data-structure-typed 1.50.8 → 1.51.0

package/src/data-structures/binary-tree/tree-multi-map.ts

@@ -9,6 +9,7 @@ import type {
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
   BTNCallback,
+  IterationType,
   KeyOrNodeOrEntry,
   TreeMultiMapNested,
   TreeMultiMapNodeNested,
@@ -24,17 +25,19 @@ export class TreeMultiMapNode<
   NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>
 > extends RedBlackTreeNode<K, V, NODE> {
   /**
-   * The constructor function initializes an instance of a class with a key, value, and count.
-   * @param {K} key - The key parameter is of type K, which represents the type of the key for the
-   * constructor. It is required and must be provided when creating an instance of the class.
-   * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
-   * value associated with the key in the constructor. If no value is provided, it will be `undefined`.
-   * @param [count=1] - The "count" parameter is an optional parameter that specifies the number of
-   * times the key-value pair should be repeated. If no value is provided for "count", it defaults to
-   * 1.
+   * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
+   * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
+   * used to identify and locate the node within the tree.
+   * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+   * associated with the key in the Red-Black Tree node. It is not required and can be omitted when
+   * creating a new node.
+   * @param [count=1] - The `count` parameter represents the number of occurrences of a particular key
+   * in the Red-Black Tree. It is an optional parameter with a default value of 1.
+   * @param {RBTNColor} [color=BLACK] - The `color` parameter is used to specify the color of the node
+   * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
    */
-  constructor(key: K, value?: V, count = 1) {
-    super(key, value);
+  constructor(key: K, value?: V, count = 1, color: RBTNColor = 'BLACK') {
+    super(key, value, color);
     this.count = count;
   }
 
@@ -91,25 +94,41 @@ export class TreeMultiMap<
     return this._count;
   }
 
-  getMutableCount(): number {
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function calculates the sum of the count property of all nodes in a tree using depth-first
+   * search.
+   * @returns the sum of the count property of all nodes in the tree.
+   */
+  getComputedCount(): number {
     let sum = 0;
     this.dfs(node => (sum += node.count));
     return sum;
   }
 
   /**
-   * The function creates a new TreeMultiMapNode object with the specified key, value, and count.
+   * The function creates a new TreeMultiMapNode with the specified key, value, color, and count.
    * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
-   * which is a generic type that can be replaced with any specific type when using the function.
-   * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-   * associated with the key in the node. It is of type `V`, which can be any data type.
-   * @param {number} [count] - The `count` parameter represents the number of occurrences of a
-   * key-value pair in the TreeMultiMap. It is an optional parameter, so if it is not provided, it will
-   * default to 1.
-   * @returns a new instance of the TreeMultiMapNode class, casted as NODE.
+   * which is a generic type representing the key type of the node.
+   * @param {V} [value] - The `value` parameter represents the value associated with the key in the
+   * node. It is an optional parameter, which means it can be omitted when calling the `createNode`
+   * function. If provided, it should be of type `V`.
+   * @param {RBTNColor} [color=BLACK] - The color parameter is used to specify the color of the node in
+   * a Red-Black Tree. It can have two possible values: 'RED' or 'BLACK'. The default value is 'BLACK'.
+   * @param {number} [count] - The `count` parameter represents the number of occurrences of a key in
+   * the tree. It is an optional parameter and is used to keep track of the number of values associated
+   * with a key in the tree.
+   * @returns A new instance of the TreeMultiMapNode class is being returned.
    */
-  override createNode(key: K, value?: V, count?: number): NODE {
-    return new TreeMultiMapNode(key, value, count) as NODE;
+  override createNode(key: K, value?: V, color: RBTNColor = 'BLACK', count?: number): NODE {
+    return new TreeMultiMapNode(key, value, count, color) as NODE;
   }
 
   /**
@@ -153,10 +172,10 @@ export class TreeMultiMap<
       if (key === undefined || key === null) {
         return;
       } else {
-        node = this.createNode(key, value, count);
+        node = this.createNode(key, value, 'BLACK', count);
       }
     } else if (!this.isNode(keyOrNodeOrEntry)) {
-      node = this.createNode(keyOrNodeOrEntry, value, count);
+      node = this.createNode(keyOrNodeOrEntry, value, 'BLACK', count);
     } else {
       return;
     }
@@ -314,7 +333,7 @@ export class TreeMultiMap<
     this._size--;
 
     // If the original color was black, fix the tree
-    if (originalColor === RBTNColor.BLACK) {
+    if (originalColor === 'BLACK') {
       this._deleteFixup(replacementNode);
     }
 
@@ -356,8 +375,8 @@ export class TreeMultiMap<
    * values:
    * @returns a boolean value.
    */
-  override perfectlyBalance(iterationType = this.iterationType): boolean {
-    const sorted = this.dfs(node => node, 'in'),
+  override perfectlyBalance(iterationType: IterationType = this.iterationType): boolean {
+    const sorted = this.dfs(node => node, 'IN'),
       n = sorted.length;
     if (sorted.length < 1) return false;
 
@@ -431,7 +450,7 @@ export class TreeMultiMap<
     destNode = this.ensureNode(destNode);
     if (srcNode && destNode) {
       const { key, value, count, color } = destNode;
-      const tempNode = this.createNode(key, value, count);
+      const tempNode = this.createNode(key, value, color, count);
       if (tempNode) {
         tempNode.color = color;
 

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

@@ -247,10 +247,10 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * Space Complexity: O(log n)
    *
    * Depth-first search (DFS) method, different traversal orders can be selected。
-   * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
+   * @param order - Traverse order parameter: 'IN' (in-order), 'PRE' (pre-order) or 'POST' (post-order).
    * @returns An array containing elements traversed in the specified order.
    */
-  dfs(order: DFSOrderPattern = 'pre'): E[] {
+  dfs(order: DFSOrderPattern = 'PRE'): E[] {
     const result: E[] = [];
 
     // Auxiliary recursive function, traverses the binary heap according to the traversal order
@@ -258,15 +258,15 @@ export class Heap<E = any> extends IterableElementBase<E> {
       const left = 2 * index + 1,
         right = left + 1;
       if (index < this.size) {
-        if (order === 'in') {
+        if (order === 'IN') {
           _dfs(left);
           result.push(this.elements[index]);
           _dfs(right);
-        } else if (order === 'pre') {
+        } else if (order === 'PRE') {
           result.push(this.elements[index]);
           _dfs(left);
           _dfs(right);
-        } else if (order === 'post') {
+        } else if (order === 'POST') {
           _dfs(left);
           _dfs(right);
           result.push(this.elements[index]);

package/src/types/common.ts

@@ -13,7 +13,7 @@ export type FamilyPosition = 'ROOT' | 'LEFT' | 'RIGHT' | 'ROOT_LEFT' | 'ROOT_RIG
 
 export type Comparator<K> = (a: K, b: K) => number;
 
-export type DFSOrderPattern = 'pre' | 'in' | 'post';
+export type DFSOrderPattern = 'PRE' | 'IN' | 'POST';
 
 export type NodeDisplayLayout = [string[], number, number, number];
 

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

@@ -1,7 +1,7 @@
 import { RedBlackTree, RedBlackTreeNode } from '../../../data-structures';
 import type { BSTOptions } from "./bst";
 
-export enum RBTNColor { RED = 1, BLACK = 0}
+export type RBTNColor = 'RED' | 'BLACK';
 
 export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 

package/test/integration/all-in-one.test.ts

@@ -23,7 +23,7 @@ describe('AVL Tree Test from data-structure-typed', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && tree.dfs(node => (subTreeSum += node.key), 'pre', 15);
+    node15 && tree.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -33,7 +33,7 @@ describe('AVL Tree Test from data-structure-typed', () => {
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
     expect(node15?.value).toBe(15);
 
-    const dfs = tree.dfs(node => node, 'in');
+    const dfs = tree.dfs(node => node, 'IN');
     expect(dfs[0].key).toBe(1);
     expect(dfs[dfs.length - 1].key).toBe(16);
 

package/test/integration/avl-tree.test.ts

@@ -1,4 +1,4 @@
-import { AVLTree, CP } from 'avl-tree-typed';
+import { AVLTree } from 'avl-tree-typed';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
@@ -40,17 +40,17 @@ describe('AVL Tree Test', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && tree.dfs(node => (subTreeSum += node.key), 'in', 15);
+    node15 && tree.dfs(node => (subTreeSum += node.key), 'IN', 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
     expect(lesserSum).toBe(45);
 
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
     expect(node15?.value).toBe(15);
 
-    const dfs = tree.dfs(node => node, 'in');
+    const dfs = tree.dfs(node => node, 'IN');
     expect(dfs[0].key).toBe(1);
     expect(dfs[dfs.length - 1].key).toBe(16);
 

package/test/integration/bst.test.ts

@@ -1,4 +1,4 @@
-import { BST, BSTNode, CP } from 'bst-typed';
+import { BST, BSTNode } from 'bst-typed';
 
 describe('Individual package BST operations test', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
@@ -34,11 +34,11 @@ describe('Individual package BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && bst.dfs(node => (subTreeSum += node.key), 'in', 15);
+    node15 && bst.dfs(node => (subTreeSum += node.key), 'IN', 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -46,7 +46,7 @@ describe('Individual package BST operations test', () => {
     const node11 = bst.getNode(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
-    const dfsInorderNodes = bst.dfs(node => node, 'in');
+    const dfsInorderNodes = bst.dfs(node => node, 'IN');
     expect(dfsInorderNodes[0].key).toBe(1);
     expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
 
@@ -231,11 +231,11 @@ describe('Individual package BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && objBST.dfs(node => (subTreeSum += node.key), 'in', node15);
+    node15 && objBST.dfs(node => (subTreeSum += node.key), 'IN', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -243,7 +243,7 @@ describe('Individual package BST operations test', () => {
     const node11 = objBST.getNode(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
-    const dfsInorderNodes = objBST.dfs(node => node, 'in');
+    const dfsInorderNodes = objBST.dfs(node => node, 'IN');
     expect(dfsInorderNodes[0].key).toBe(1);
     expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
 

package/test/integration/index.html

@@ -28,14 +28,14 @@
     const n = 1000000;
     const startEn = performance.now();
     for (let i = 0; i < n; i++) {
-      queue.enqueue(i);
+      queue.push(i);
     }
     console.log((performance.now() - startEn).toFixed(2), `Queue ${n.toLocaleString()} enqueue `);
     let last = 0;
     const startTime = performance.now();
 
     for (let i = 0; i < n; i++) {
-      last = queue.dequeue();
+      last = queue.shift();
     }
 
     console.log((performance.now() - startTime).toFixed(2), `Queue ${n.toLocaleString()} dequeue `);

package/test/performance/data-structures/binary-tree/avl-tree.test.ts

@@ -3,26 +3,31 @@ import * as Benchmark from 'benchmark';
 import { getRandomIntArray, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const avl = new AVLTree<number>();
-const { TEN_THOUSAND } = magnitude;
-const arr = getRandomIntArray(TEN_THOUSAND, 0, TEN_THOUSAND, true);
+const avlTree = new AVLTree<number>();
+const { HUNDRED_THOUSAND } = magnitude;
+const randomArray = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND - 1, true);
 
 suite
-  .add(`${TEN_THOUSAND.toLocaleString()} add randomly`, () => {
-    avl.clear();
-    for (let i = 0; i < arr.length; i++) avl.add(arr[i]);
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
+    avlTree.clear();
+    for (let i = 0; i < randomArray.length; i++) avlTree.add(i);
   })
-  .add(`${TEN_THOUSAND.toLocaleString()} get`, () => {
-    for (let i = 0; i < arr.length; i++) avl.get(arr[i]);
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
+    for (let i = 0; i < randomArray.length; i++) avlTree.get(randomArray[i]);
   })
-  .add(`${TEN_THOUSAND.toLocaleString()} add & delete randomly`, () => {
-    avl.clear();
-    for (let i = 0; i < arr.length; i++) avl.add(arr[i]);
-    for (let i = 0; i < arr.length; i++) avl.delete(arr[i]);
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} iterator`, () => {
+    const entries = [...avlTree];
+    return entries.length === HUNDRED_THOUSAND;
   })
-  .add(`${TEN_THOUSAND.toLocaleString()} addMany`, () => {
-    avl.clear();
-    avl.addMany(arr);
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete orderly`, () => {
+    avlTree.clear();
+    for (let i = 0; i < randomArray.length; i++) avlTree.add(i);
+    for (let i = 0; i < randomArray.length; i++) avlTree.delete(i);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete randomly`, () => {
+    avlTree.clear();
+    for (let i = 0; i < randomArray.length; i++) avlTree.add(randomArray[i]);
+    for (let i = 0; i < randomArray.length; i++) avlTree.delete(randomArray[i]);
   });
 
 export { suite };

package/test/performance/data-structures/binary-tree/binary-tree.test.ts

@@ -34,7 +34,7 @@ suite
     for (let i = 0; i < THOUSAND; i++) biTree.bfs();
   })
   .add(`${THOUSAND.toLocaleString()} morris`, () => {
-    for (let i = 0; i < THOUSAND; i++) biTree.morris(n => n, 'pre');
+    for (let i = 0; i < THOUSAND; i++) biTree.morris(n => n, 'PRE');
   });
 
 // export { suite };

package/test/unit/data-structures/binary-tree/avl-tree-multi-map.test.ts

@@ -31,7 +31,7 @@ describe('AVLTreeMultiMap count', () => {
     tm.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 1);
     tm.delete(2);
     expect(tm.count).toBe(12);
-    expect(tm.getMutableCount()).toBe(16);
+    expect(tm.getComputedCount()).toBe(16);
   });
 });
 
@@ -91,7 +91,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
-    node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
+    node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), 'LT', 10);
@@ -99,7 +99,7 @@ describe('AVLTreeMultiMap operations test1', () => {
 
     expect(node15 instanceof AVLTreeMultiMapNode);
     if (node15 instanceof AVLTreeMultiMapNode) {
-      const subTreeAdd = treeMultimap.dfs(node => (node.count += 1), 'pre', 15);
+      const subTreeAdd = treeMultimap.dfs(node => (node.count += 1), 'PRE', 15);
       expect(subTreeAdd);
     }
     const node11 = treeMultimap.getNode(11);
@@ -109,7 +109,7 @@ describe('AVLTreeMultiMap operations test1', () => {
       expect(allGreaterNodesAdded);
     }
 
-    const dfsInorderNodes = treeMultimap.dfs(node => node, 'in');
+    const dfsInorderNodes = treeMultimap.dfs(node => node, 'IN');
     expect(dfsInorderNodes[0].key).toBe(1);
     expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
     expect(treeMultimap.isPerfectlyBalanced()).toBe(false);
@@ -345,7 +345,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
-    node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
+    node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), 'LT', 10);
@@ -353,7 +353,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
 
     expect(node15 instanceof AVLTreeMultiMapNode);
     if (node15 instanceof AVLTreeMultiMapNode) {
-      const subTreeAdd = treeMultimap.dfs(node => (node.count += 1), 'pre', 15);
+      const subTreeAdd = treeMultimap.dfs(node => (node.count += 1), 'PRE', 15);
       expect(subTreeAdd);
     }
     const node11 = treeMultimap.getNode(11);
@@ -363,7 +363,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
       expect(allGreaterNodesAdded);
     }
 
-    const dfsInorderNodes = treeMultimap.dfs(node => node, 'in');
+    const dfsInorderNodes = treeMultimap.dfs(node => node, 'IN');
     expect(dfsInorderNodes[0].key).toBe(1);
     expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
     expect(treeMultimap.isPerfectlyBalanced()).toBe(true);

package/test/unit/data-structures/binary-tree/avl-tree.test.ts

@@ -24,7 +24,7 @@ describe('AVL Tree Test', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && tree.dfs(node => (subTreeSum += node.key), 'pre', node15);
+    node15 && tree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -34,7 +34,7 @@ describe('AVL Tree Test', () => {
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
     expect(node15?.value).toBe(15);
 
-    const dfs = tree.dfs(node => node, 'in');
+    const dfs = tree.dfs(node => node, 'IN');
     expect(dfs[0].key).toBe(1);
     expect(dfs[dfs.length - 1].key).toBe(16);
     tree.perfectlyBalance();
@@ -132,7 +132,7 @@ describe('AVL Tree Test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && tree.dfs(node => (subTreeSum += node.key), 'pre', node15);
+    node15 && tree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -142,7 +142,7 @@ describe('AVL Tree Test recursively', () => {
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
     expect(node15?.value).toBe(15);
 
-    const dfs = tree.dfs(node => node, 'in');
+    const dfs = tree.dfs(node => node, 'IN');
     expect(dfs[0].key).toBe(1);
     expect(dfs[dfs.length - 1].key).toBe(16);
 

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

@@ -171,20 +171,20 @@ describe('BinaryTree', () => {
     expect(cloned.root?.right?.key).toBe(6);
     expect(cloned.root?.right?.left?.key).toBe(3);
     expect(cloned.root?.right?.right).toBe(null);
-    expect(cloned.dfs(node => node.key, 'pre', cloned.getNode(6), 'ITERATIVE')).toEqual([6, 3, 7]);
-    expect(cloned.dfs(node => (node ? node.key : null), 'pre', cloned.getNode(6), 'ITERATIVE', true)).toEqual([
+    expect(cloned.dfs(node => node.key, 'PRE', cloned.getNode(6), 'ITERATIVE')).toEqual([6, 3, 7]);
+    expect(cloned.dfs(node => (node ? node.key : null), 'PRE', cloned.getNode(6), 'ITERATIVE', true)).toEqual([
       6,
       3,
       7,
       null
     ]);
-    expect(cloned.dfs(node => (node ? node.key : node), 'pre', cloned.getNode(6), 'ITERATIVE', true)).toEqual([
+    expect(cloned.dfs(node => (node ? node.key : node), 'PRE', cloned.getNode(6), 'ITERATIVE', true)).toEqual([
       6,
       3,
       7,
       null
     ]);
-    expect(cloned.dfs(node => (node ? node.key : null), 'pre', cloned.getNode(6), 'RECURSIVE', true)).toEqual([
+    expect(cloned.dfs(node => (node ? node.key : null), 'PRE', cloned.getNode(6), 'RECURSIVE', true)).toEqual([
       6,
       3,
       7,
@@ -294,22 +294,22 @@ describe('BinaryTree', () => {
 
   it('should sub tree traverse', () => {
     tree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
-    expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), 'ITERATIVE')).toEqual([6, 3, 7]);
-    expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), 'ITERATIVE', false)).toEqual([6, 3, 7]);
-    expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), 'RECURSIVE')).toEqual([6, 3, 7]);
-    expect(tree.dfs(node => (node ? node.key : null), 'pre', tree.getNode(6), 'ITERATIVE', true)).toEqual([
+    expect(tree.dfs(node => node.key, 'PRE', tree.getNode(6), 'ITERATIVE')).toEqual([6, 3, 7]);
+    expect(tree.dfs(node => node.key, 'PRE', tree.getNode(6), 'ITERATIVE', false)).toEqual([6, 3, 7]);
+    expect(tree.dfs(node => node.key, 'PRE', tree.getNode(6), 'RECURSIVE')).toEqual([6, 3, 7]);
+    expect(tree.dfs(node => (node ? node.key : null), 'PRE', tree.getNode(6), 'ITERATIVE', true)).toEqual([
       6,
       3,
       7,
       null
     ]);
-    expect(tree.dfs(node => (node ? node.key : node), 'pre', tree.getNode(6), 'ITERATIVE', true)).toEqual([
+    expect(tree.dfs(node => (node ? node.key : node), 'PRE', tree.getNode(6), 'ITERATIVE', true)).toEqual([
       6,
       3,
       7,
       null
     ]);
-    expect(tree.dfs(node => (node ? node.key : null), 'pre', tree.getNode(6), 'RECURSIVE', true)).toEqual([
+    expect(tree.dfs(node => (node ? node.key : null), 'PRE', tree.getNode(6), 'RECURSIVE', true)).toEqual([
       6,
       3,
       7,
@@ -362,36 +362,36 @@ describe('BinaryTree Morris Traversal', () => {
   tree.add(5);
   it('should perform in-order Morris traversal correctly as dfs traversal', () => {
     // Perform in-order Morris traversal
-    const result = tree.morris(node => node.key, 'in');
+    const result = tree.morris(node => node.key, 'IN');
 
     // Expected in-order traversal result
     const expected = [4, 2, 5, 1, 3];
 
     expect(result).toEqual(expected);
-    expect(tree.dfs(node => node.key, 'in')).toEqual(expected);
-    expect(tree.dfs(node => node.key, 'in', tree.root, 'RECURSIVE')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'IN', tree.root, 'RECURSIVE')).toEqual(expected);
   });
 
   it('should perform pre-order Morris traversal correctly as dfs traversal', () => {
     // Perform pre-order Morris traversal
-    const result = tree.morris(node => node.key, 'pre');
+    const result = tree.morris(node => node.key, 'PRE');
 
     // Expected pre-order traversal result
     const expected = [1, 2, 4, 5, 3];
 
     expect(result).toEqual(expected);
-    expect(tree.dfs(node => node.key, 'pre')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'PRE')).toEqual(expected);
   });
 
   it('should perform post-order Morris traversal correctly as dfs traversal', () => {
     // Perform post-order Morris traversal
-    const result = tree.morris(node => node.key, 'post');
+    const result = tree.morris(node => node.key, 'POST');
 
     // Expected post-order traversal result
     const expected = [4, 5, 2, 3, 1];
 
     expect(result).toEqual([4, 5, 2, 3, 1]);
-    expect(tree.dfs(node => node.key, 'post')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'POST')).toEqual(expected);
   });
 
   it('after morris traversals should the structure of the tree be correct', () => {
@@ -445,11 +445,11 @@ describe('BinaryTree traversals', () => {
     35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
   ]);
 
-  expect(tree.dfs(node => node.key, 'pre')).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
-  expect(tree.dfs(node => node.key, 'pre', tree.root, 'RECURSIVE')).toEqual([
+  expect(tree.dfs(node => node.key, 'PRE')).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
+  expect(tree.dfs(node => node.key, 'PRE', tree.root, 'RECURSIVE')).toEqual([
     35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55
   ]);
-  expect(tree.dfs(node => node, 'pre', tree.root, 'ITERATIVE', true).map(node => (node ? node.key : null))).toEqual([
+  expect(tree.dfs(node => node, 'PRE', tree.root, 'ITERATIVE', true).map(node => (node ? node.key : null))).toEqual([
     35,
     20,
     15,
@@ -464,7 +464,7 @@ describe('BinaryTree traversals', () => {
     45,
     55
   ]);
-  expect(tree.dfs(node => node, 'pre', tree.root, 'RECURSIVE', true).map(node => (node ? node.key : null))).toEqual([
+  expect(tree.dfs(node => node, 'PRE', tree.root, 'RECURSIVE', true).map(node => (node ? node.key : null))).toEqual([
     35,
     20,
     15,
@@ -480,9 +480,9 @@ describe('BinaryTree traversals', () => {
     55
   ]);
 
-  expect(tree.dfs(node => node.key, 'in')).toEqual([15, 16, 20, 28, 29, 30, 35, 40, 45, 50, 55]);
-  expect(tree.dfs(node => node.key, 'post')).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
-  expect(tree.dfs(node => node.key, 'post', tree.root, 'RECURSIVE')).toEqual([
+  expect(tree.dfs(node => node.key, 'IN')).toEqual([15, 16, 20, 28, 29, 30, 35, 40, 45, 50, 55]);
+  expect(tree.dfs(node => node.key, 'POST')).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
+  expect(tree.dfs(node => node.key, 'POST', tree.root, 'RECURSIVE')).toEqual([
     16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35
   ]);
   expect(tree.bfs(node => node.key, tree.root, 'RECURSIVE')).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);