data-structure-typed 1.53.0 → 1.53.2

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "data-structure-typed",
-  "version": "1.53.0",
+  "version": "1.53.2",
   "description": "Javascript Data Structure. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
+  "browser": "dist/umd/data-structure-typed.min.js",
   "types": "dist/mjs/index.d.ts",
   "umd:main": "dist/umd/data-structure-typed.min.js",
   "exports": {
@@ -68,11 +69,11 @@
     "@typescript-eslint/eslint-plugin": "^8.12.1",
     "@typescript-eslint/parser": "^8.12.1",
     "auto-changelog": "^2.5.0",
-    "avl-tree-typed": "^1.52.9",
+    "avl-tree-typed": "^1.53.1",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.52.9",
-    "bst-typed": "^1.52.9",
-    "data-structure-typed": "^1.52.9",
+    "binary-tree-typed": "^1.53.1",
+    "bst-typed": "^1.53.1",
+    "data-structure-typed": "^1.53.1",
     "dependency-cruiser": "^16.5.0",
     "doctoc": "^2.2.1",
     "eslint": "^9.13.0",
@@ -81,7 +82,7 @@
     "eslint-import-resolver-typescript": "^3.6.3",
     "eslint-plugin-import": "^2.31.0",
     "fast-glob": "^3.3.2",
-    "heap-typed": "^1.52.9",
+    "heap-typed": "^1.53.1",
     "istanbul-badges-readme": "^1.9.0",
     "jest": "^29.7.0",
     "js-sdsl": "^4.4.2",

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

@@ -129,7 +129,7 @@ export class AVLTreeMultiMap<
    * @returns a new instance of the AVLTreeMultiMapNode class, casted as NODE.
    */
   override createNode(key: K, value?: V, count?: number): NODE {
-    return new AVLTreeMultiMapNode(key, value, count) as NODE;
+    return new AVLTreeMultiMapNode(key, this._isMapMode ? undefined : value, count) as NODE;
   }
 
   /**

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

@@ -99,7 +99,7 @@ export class AVLTree<
    * type NODE.
    */
   override createNode(key: K, value?: V): NODE {
-    return new AVLTreeNode<K, V, NODE>(key, value) as NODE;
+    return new AVLTreeNode<K, V, NODE>(key, this._isMapMode ? undefined : value) as NODE;
   }
 
   /**

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

@@ -135,7 +135,7 @@ export class BinaryTree<
     if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
   }
 
-  protected _isMapMode = false;
+  protected _isMapMode = true;
 
   get isMapMode() {
     return this._isMapMode;
@@ -181,7 +181,7 @@ export class BinaryTree<
    * as NODE.
    */
   createNode(key: K, value?: V): NODE {
-    return new BinaryTreeNode<K, V, NODE>(key, value) as NODE;
+    return new BinaryTreeNode<K, V, NODE>(key, this._isMapMode ? undefined : value) as NODE;
   }
 
   /**

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

@@ -141,7 +141,7 @@ export class BST<
    * @returns The method is returning a new instance of the BSTNode class, casted as the NODE type.
    */
   override createNode(key: K, value?: V): NODE {
-    return new BSTNode<K, V, NODE>(key, value) as NODE;
+    return new BSTNode<K, V, NODE>(key, this._isMapMode ? undefined : value) as NODE;
   }
 
   /**
@@ -174,9 +174,9 @@ export class BST<
     keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
     value?: V
   ): [OptNode<NODE>, V | undefined] {
-    const [node, tValue] = super.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    const [node, entryValue] = super.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
     if (node === null) return [undefined, undefined];
-    return [node, tValue ?? value];
+    return [node, value ?? entryValue];
   }
 
   /**
@@ -250,6 +250,7 @@ export class BST<
     while (current !== undefined) {
       if (this.comparator(current.key, newNode.key) === 0) {
         this._replaceNode(current, newNode);
+        if (this._isMapMode) this._setValue(current.key, newValue);
         return true;
       } else if (this.comparator(current.key, newNode.key) > 0) {
         if (current.left === undefined) {

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

@@ -106,7 +106,7 @@ export class RedBlackTree<
    * returned.
    */
   override createNode(key: K, value?: V, color: RBTNColor = 'BLACK'): NODE {
-    return new RedBlackTreeNode<K, V, NODE>(key, value, color) as NODE;
+    return new RedBlackTreeNode<K, V, NODE>(key, this._isMapMode ? undefined : value, color) as NODE;
   }
 
   /**
@@ -218,7 +218,12 @@ export class RedBlackTree<
       if (this._isMapMode) this._setValue(newNode.key, newValue);
       this._size++;
       return true;
-    } else return insertStatus === 'UPDATED';
+    }
+    if (insertStatus === 'UPDATED') {
+      if (this._isMapMode) this._setValue(newNode.key, newValue);
+      return true;
+    }
+    return false;
   }
 
   /**

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

@@ -124,7 +124,7 @@ export class TreeMultiMap<
    * @returns A new instance of the TreeMultiMapNode class, casted as NODE.
    */
   override createNode(key: K, value?: V, color: RBTNColor = 'BLACK', count?: number): NODE {
-    return new TreeMultiMapNode(key, value, count, color) as NODE;
+    return new TreeMultiMapNode(key, this._isMapMode ? undefined : value, count, color) as NODE;
   }
 
   /**

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

@@ -9,9 +9,9 @@ export type BinaryTreeNested<K, V, R, NODE extends BinaryTreeNode<K, V, NODE>> =
 export type ToEntryFn<K, V, R> = (rawElement: R) => BTNEntry<K, V>;
 
 export type BinaryTreeOptions<K, V, R> = {
-    iterationType?: IterationType;
-    toEntryFn?: ToEntryFn<K, V, R>;
-    isMapMode?: boolean;
+  iterationType?: IterationType;
+  toEntryFn?: ToEntryFn<K, V, R>;
+  isMapMode?: boolean;
 }
 
 export type BinaryTreePrintOptions = { isShowUndefined?: boolean; isShowNull?: boolean; isShowRedBlackNIL?: boolean };

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

@@ -7,7 +7,7 @@ export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTN
 export type BSTNested<K, V, R, NODE extends BSTNode<K, V, NODE>> = BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
-    comparator?: Comparator<K>
+  comparator?: Comparator<K>
 }
 
 export type BSTNOptKey<K> = K | undefined;

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

@@ -3,7 +3,7 @@ import * as Benchmark from 'benchmark';
 import { getRandomIntArray, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const avlTree = new AVLTree<number>([], { isMapMode: true });
+const avlTree = new AVLTree<number>();
 const { HUNDRED_THOUSAND } = magnitude;
 const randomArray = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND - 1, true);
 

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

@@ -3,8 +3,8 @@ import * as Benchmark from 'benchmark';
 import { getRandomIntArray, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const rbTree = new RedBlackTree<number>([], { isMapMode: true });
-const avlTree = new AVLTree<number>([], { isMapMode: true });
+const rbTree = new RedBlackTree<number>();
+const avlTree = new AVLTree<number>();
 const { TEN_THOUSAND } = magnitude;
 const arr = getRandomIntArray(TEN_THOUSAND, 0, TEN_THOUSAND - 1, true);
 

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

@@ -3,7 +3,7 @@ import * as Benchmark from 'benchmark';
 import { getRandomIntArray, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const biTree = new BinaryTree<number>([], { isMapMode: true });
+const biTree = new BinaryTree<number>();
 const { THOUSAND } = magnitude;
 const arr = getRandomIntArray(THOUSAND, 0, THOUSAND, true);
 

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

@@ -3,7 +3,7 @@ import * as Benchmark from 'benchmark';
 import { getRandomIntArray, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const bst = new BST<number>([], { isMapMode: true });
+const bst = new BST<number>();
 const { TEN_THOUSAND } = magnitude;
 const arr = getRandomIntArray(TEN_THOUSAND, 0, TEN_THOUSAND, true);
 

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

@@ -5,7 +5,8 @@ import { OrderedMap } from 'js-sdsl';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const rbTree = new RedBlackTree<number>([], { isMapMode: true });
+const rbTree = new RedBlackTree<number>();
+const rbTreeNodeMode = new RedBlackTree<number>([], { isMapMode: false });
 const { HUNDRED_THOUSAND } = magnitude;
 const randomArray = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND - 1, true);
 const cOrderedMap = new OrderedMap<number, number>();
@@ -22,6 +23,13 @@ suite
   .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
     for (let i = 0; i < randomArray.length; i++) rbTree.get(randomArray[i]);
   })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} node mode add randomly`, () => {
+    rbTreeNodeMode.clear();
+    for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} node mode get`, () => {
+    for (let i = 0; i < randomArray.length; i++) rbTreeNodeMode.get(randomArray[i]);
+  })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} iterator`, () => {
     const entries = [...rbTree];
     return entries.length === HUNDRED_THOUSAND;

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

@@ -75,7 +75,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     const nodeId10 = treeMultimap.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = treeMultimap.getNode(node => node.value === 9);
+    const nodeVal9 = treeMultimap.getNode(node => node.key === 9);
     expect(nodeVal9?.key).toBe(9);
 
     const nodesByCount1 = treeMultimap.getNodes(node => node.count === 1);
@@ -331,7 +331,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     const nodeId10 = treeMultimap.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = treeMultimap.getNode(node => node.value === 9);
+    const nodeVal9 = treeMultimap.getNode(node => node.key === 9);
     expect(nodeVal9?.key).toBe(9);
 
     const nodesByCount1 = treeMultimap.getNodes(node => node.count === 1);
@@ -762,10 +762,10 @@ describe('AVLTree toEntryFn', () => {
   });
 });
 
-describe('AVLTreeMultiMap map mode count', () => {
+describe('AVLTreeMultiMap not map mode count', () => {
   let tm: AVLTreeMultiMap<number>;
   beforeEach(() => {
-    tm = new AVLTreeMultiMap<number>([], { isMapMode: true });
+    tm = new AVLTreeMultiMap<number>([], { isMapMode: false });
   });
   it('Should added isolated node count ', () => {
     tm.addMany([
@@ -781,9 +781,9 @@ describe('AVLTreeMultiMap map mode count', () => {
   });
 });
 
-describe('AVLTreeMultiMap map mode operations test1', () => {
+describe('AVLTreeMultiMap not map mode operations test1', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const treeMultimap = new AVLTreeMultiMap<number>([], { isMapMode: true });
+    const treeMultimap = new AVLTreeMultiMap<number>([], { isMapMode: false });
 
     expect(treeMultimap instanceof AVLTreeMultiMap);
     treeMultimap.add([11, 11]);
@@ -826,11 +826,11 @@ describe('AVLTreeMultiMap map mode operations test1', () => {
   });
 });
 
-describe('AVLTreeMultiMap map mode operations test recursively1', () => {
+describe('AVLTreeMultiMap not map mode operations test recursively1', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
     const treeMultimap = new AVLTreeMultiMap<number>([], {
       iterationType: 'RECURSIVE',
-      isMapMode: true
+      isMapMode: false
     });
 
     expect(treeMultimap instanceof AVLTreeMultiMap);

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

@@ -32,7 +32,7 @@ describe('AVL Tree Test', () => {
     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);
+    expect(node15?.value).toBe(undefined);
     const dfs = tree.dfs(node => node, 'IN');
     expect(dfs[0].key).toBe(1);
     expect(dfs[dfs.length - 1].key).toBe(16);
@@ -106,6 +106,25 @@ describe('AVL Tree Test', () => {
     expect(lastBFSNodes[1].key).toBe(2);
     expect(lastBFSNodes[2].key).toBe(16);
   });
+
+  it('should replace value', () => {
+    const tree = new AVLTree<number, string>([4, 5, [1, '1'], 2, 3], { isMapMode: false });
+    expect(tree.get(1)).toBe('1');
+    expect(tree.getNode(1)?.value).toBe('1');
+    tree.add(1, 'a');
+    expect(tree.get(1)).toBe('a');
+    tree.add([1, 'b']);
+    expect(tree.getNode(1)?.value).toBe('b');
+    expect(tree.get(1)).toBe('b');
+    const treeMap = new AVLTree<number>([4, 5, [1, '1'], 2, 3]);
+    expect(treeMap.get(1)).toBe('1');
+    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    treeMap.add(1, 'a');
+    expect(treeMap.get(1)).toBe('a');
+    treeMap.add([1, 'b']);
+    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    expect(treeMap.get(1)).toBe('b');
+  });
 });
 
 describe('AVL Tree Test recursively', () => {
@@ -139,7 +158,7 @@ describe('AVL Tree Test recursively', () => {
     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);
+    expect(node15?.value).toBe(undefined);
 
     const dfs = tree.dfs(node => node, 'IN');
     expect(dfs[0].key).toBe(1);
@@ -418,7 +437,7 @@ describe('AVLTree iterative methods test', () => {
   it('should clone work well', () => {
     const cloned = avl.clone();
     expect(cloned.root?.left?.key).toBe(1);
-    expect(cloned.root?.right?.value).toBe('c');
+    expect(cloned.root?.right?.value).toBe(undefined);
   });
 
   it('should keys', () => {
@@ -437,10 +456,10 @@ describe('AVLTree iterative methods test', () => {
   });
 });
 
-describe('AVL Tree map mode', () => {
+describe('AVL Tree not map mode', () => {
   it('should perform various operations on a AVL Tree', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    const tree = new AVLTree<number>([], { isMapMode: true });
+    const tree = new AVLTree<number>([], { isMapMode: false });
 
     for (const i of arr) tree.add([i, i]);
 
@@ -473,10 +492,10 @@ describe('AVL Tree map mode', () => {
   });
 });
 
-describe('AVL Tree map mode test recursively', () => {
+describe('AVL Tree not map mode test recursively', () => {
   it('should perform various operations on a AVL Tree', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    const tree = new AVLTree<number>([], { iterationType: 'RECURSIVE', isMapMode: true });
+    const tree = new AVLTree<number>([], { iterationType: 'RECURSIVE', isMapMode: false });
 
     for (const i of arr) tree.add([i, i]);
 
@@ -508,10 +527,10 @@ describe('AVL Tree map mode test recursively', () => {
   });
 });
 
-describe('AVLTree iterative methods map mode', () => {
+describe('AVLTree iterative methods not map mode', () => {
   let avl: AVLTree<number, string>;
   beforeEach(() => {
-    avl = new AVLTree<number, string>([], { isMapMode: true });
+    avl = new AVLTree<number, string>([], { isMapMode: false });
     avl.add([1, 'a']);
     avl.add([2, 'b']);
     avl.add([3, 'c']);

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

@@ -102,10 +102,10 @@ describe('BinaryTree addMany', () => {
       ],
       [undefined, 22, 44, 33]
     );
-    expect(tree.getNodeByKey(2)?.value).toBe(22);
-    expect(tree.getNodeByKey(3)?.value).toBe(33);
-    expect(tree.getNodeByKey(4)?.value).toBe(44);
-    expect(tree.getNodeByKey(1)?.value).toBe(1);
+    expect(tree.get(2)).toBe(22);
+    expect(tree.get(tree.getNodeByKey(3))).toBe(33);
+    expect(tree.get(tree.getNodeByKey(4))).toBe(44);
+    expect(tree.get(tree.getNodeByKey(1))).toBe(1);
   });
 
   it('should addMany undefined and null', () => {
@@ -193,7 +193,7 @@ describe('BinaryTree', () => {
     const node4 = tree.getNode(4);
     expect(tree.has(node4)).toBe(false);
     expect(tree.has(node => node === node4)).toBe(false);
-    expect(tree.has(node => node.value?.toString() === '3')).toBe(true);
+    expect(tree.has(node => node.key?.toString() === '3')).toBe(true);
   });
 
   it('should the clone method work fine', () => {
@@ -768,6 +768,25 @@ describe('BinaryTree', () => {
     });
     expect(bTree.keyValueNodeEntryRawToNodeAndValue({ obj: { id: 1 } })).toEqual([undefined, undefined]);
   });
+
+  it('should replace value', () => {
+    const tree = new BinaryTree<number, string>([4, 5, [1, '1'], 2, 3], { isMapMode: false });
+    expect(tree.get(1)).toBe('1');
+    expect(tree.getNode(1)?.value).toBe('1');
+    tree.add(1, 'a');
+    expect(tree.get(1)).toBe('a');
+    tree.add([1, 'b']);
+    expect(tree.getNode(1)?.value).toBe('b');
+    expect(tree.get(1)).toBe('b');
+    const treeMap = new BinaryTree<number>([4, 5, [1, '1'], 2, 3]);
+    expect(treeMap.get(1)).toBe('1');
+    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    treeMap.add(1, 'a');
+    expect(treeMap.get(1)).toBe('a');
+    treeMap.add([1, 'b']);
+    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    expect(treeMap.get(1)).toBe('b');
+  });
 });
 
 describe('BinaryTree ensureNode', () => {
@@ -1049,9 +1068,9 @@ describe('BinaryTree', () => {
     const nodeB = tree.getNode(3);
 
     expect(nodeA?.key).toBe(5);
-    expect(nodeA?.value).toBe('A');
+    expect(nodeA?.value).toBe(undefined);
     expect(nodeB?.key).toBe(3);
-    expect(nodeB?.value).toBe('B');
+    expect(tree.get(nodeB)).toBe('B');
   });
 
   it('should return null when getting a non-existent node', () => {
@@ -1160,21 +1179,17 @@ describe('BinaryTree', () => {
     tree.add([2, 'B']);
     tree.add([null, 'null']);
 
-    const nodes = tree.isMapMode ? tree.getNodes(node => node.key === 2) : tree.getNodes(node => node.value === 'B');
+    const nodes = tree.getNodes(node => node.key === 2);
 
     expect(nodes.length).toBe(1);
     expect(nodes[0].key).toBe(2);
 
-    const nodesRec = tree.isMapMode
-      ? tree.getNodes(node => node.key === 2, false, tree.root, 'RECURSIVE')
-      : tree.getNodes(node => node.value === 'B', false, tree.root, 'RECURSIVE');
+    const nodesRec = tree.getNodes(node => node.key === 2, false, tree.root, 'RECURSIVE');
 
     expect(nodesRec.length).toBe(1);
     expect(nodesRec[0].key).toBe(2);
 
-    const nodesItr = tree.isMapMode
-      ? tree.getNodes(node => node.key === 2, false, tree.root, 'ITERATIVE')
-      : tree.getNodes(node => node.value === 'B', false, tree.root, 'ITERATIVE');
+    const nodesItr = tree.getNodes(node => node.key === 2, false, tree.root, 'ITERATIVE');
 
     expect(nodesItr.length).toBe(1);
     expect(nodesItr[0].key).toBe(2);
@@ -1220,13 +1235,13 @@ describe('BinaryTree', () => {
   });
 });
 
-describe('BinaryTree map mode', () => {
+describe('BinaryTree not map mode', () => {
   let tree: BinaryTree<number, string>;
 
   beforeEach(() => {
     tree = new BinaryTree<number, string>([], {
       iterationType: 'RECURSIVE',
-      isMapMode: true
+      isMapMode: false
     });
   });
 
@@ -1247,8 +1262,7 @@ describe('BinaryTree map mode', () => {
     const node4 = tree.getNode(4);
     expect(tree.has(node4)).toBe(false);
     expect(tree.has(node => node === node4)).toBe(false);
-    if (tree.isMapMode) expect(tree.has(node => node.key?.toString() === '3')).toBe(true);
-    else expect(tree.has(node => node.value?.toString() === '3')).toBe(true);
+    expect(tree.has(node => node.value?.toString() === '3')).toBe(true);
   });
 
   it('should isSubtreeBST', () => {
@@ -1379,8 +1393,8 @@ describe('BinaryTree iterative methods test', () => {
   it('should clone work well', () => {
     const cloned = binaryTree.clone();
     expect(cloned.root?.left?.key).toBe(2);
-    if (cloned.isMapMode) expect(cloned.get(cloned.root?.right)).toBe('c');
-    else expect(cloned.root?.right?.value).toBe('c');
+    expect(cloned.root?.right?.value).toBe(undefined);
+    expect(cloned.get(cloned.root?.right)).toBe('c');
   });
 
   it('should keys', () => {
@@ -1423,10 +1437,10 @@ describe('BinaryTree iterative methods test', () => {
   });
 });
 
-describe('BinaryTree map mode iterative methods test', () => {
+describe('BinaryTree not map mode iterative methods test', () => {
   let binaryTree: BinaryTree<number, string>;
   beforeEach(() => {
-    binaryTree = new BinaryTree<number, string>([], { isMapMode: true });
+    binaryTree = new BinaryTree<number, string>([], { isMapMode: false });
     binaryTree.add([1, 'a']);
     binaryTree.add(2, 'b');
     binaryTree.add([3, 'c']);

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

@@ -74,7 +74,7 @@ describe('BST operations test', () => {
     const nodeId10 = bst.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = bst.getNode(node => node.value === 9);
+    const nodeVal9 = bst.getNode(node => node.key === 9);
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = bst.getLeftMost();
@@ -86,7 +86,7 @@ describe('BST operations test', () => {
     const minNodeBySpecificNode = node15 && bst.getLeftMost(node => node, node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
-    const nodes = bst.getNodes(node => node.value === 15);
+    const nodes = bst.getNodes(node => node.key === 15);
     expect(nodes.map(node => node.key)).toEqual([15]);
 
     let subTreeSum = 0;
@@ -291,7 +291,7 @@ describe('BST operations test', () => {
     expect(leftMost).toBe(1);
 
     const node15 = objBST.getNode(15);
-    expect(node15?.value).toEqual({
+    expect(objBST.get(node15)).toEqual({
       name: 'Alice',
       age: 15
     });
@@ -470,6 +470,25 @@ describe('BST operations test', () => {
     const nodeNull = bst.keyValueNodeEntryRawToNodeAndValue(null);
     expect(nodeNull).toEqual([undefined, undefined]);
   });
+
+  it('should replace value', () => {
+    const tree = new BST<number, string>([4, 5, [1, '1'], 2, 3], { isMapMode: false });
+    expect(tree.get(1)).toBe('1');
+    expect(tree.getNode(1)?.value).toBe('1');
+    tree.add(1, 'a');
+    expect(tree.get(1)).toBe('a');
+    tree.add([1, 'b']);
+    expect(tree.getNode(1)?.value).toBe('b');
+    expect(tree.get(1)).toBe('b');
+    const treeMap = new BST<number>([4, 5, [1, '1'], 2, 3]);
+    expect(treeMap.get(1)).toBe('1');
+    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    treeMap.add(1, 'a');
+    expect(treeMap.get(1)).toBe('a');
+    treeMap.add([1, 'b']);
+    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    expect(treeMap.get(1)).toBe('b');
+  });
 });
 
 describe('BST operations test recursively', () => {
@@ -708,7 +727,7 @@ describe('BST operations test recursively', () => {
     expect(leftMost).toBe(1);
 
     const node15 = objBST.getNode(15);
-    expect(node15?.value).toEqual({
+    expect(objBST.get(node15)).toEqual({
       key: 15,
       keyA: 15
     });
@@ -1135,7 +1154,7 @@ describe('BST iterative methods test', () => {
   it('should clone work well', () => {
     const cloned = bst.clone();
     expect(cloned.root?.left).toBe(undefined);
-    expect(cloned.root?.right?.value).toBe('b');
+    expect(cloned.root?.right?.value).toBe(undefined);
   });
 
   it('should keys', () => {
@@ -1210,13 +1229,13 @@ describe('BST iterative methods test', () => {
     );
 
     expect(balanced.leaves()).toEqual([1, 6, 4, 9]);
-    expect(balanced.leaves(node => node?.value)).toEqual(['a', 'f', 'd', 'i']);
+    expect(balanced.leaves(node => balanced.get(node))).toEqual(['a', 'f', 'd', 'i']);
   });
 });
 
-describe('BST operations map mode test', () => {
+describe('BST operations not map mode test', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
-    const bst = new BST<number, number>([], { isMapMode: true });
+    const bst = new BST<number, number>([], { isMapMode: false });
     expect(bst).toBeInstanceOf(BST);
     bst.add([11, 11]);
     bst.add([3, 3]);
@@ -1269,7 +1288,7 @@ describe('BST operations map mode test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<number, { name: string; age: number }>([], { isMapMode: true });
+    const objBST = new BST<number, { name: string; age: number }>([], { isMapMode: false });
     expect(objBST).toBeInstanceOf(BST);
     objBST.add([11, { name: '11', age: 11 }]);
     objBST.add([3, { name: '3', age: 3 }]);
@@ -1322,7 +1341,7 @@ describe('BST operations map mode test', () => {
   });
 
   it('should keyValueNodeEntryRawToNodeAndValue', () => {
-    const bst = new BST<number>([], { isMapMode: true });
+    const bst = new BST<number>([], { isMapMode: false });
     const node0 = bst.keyValueNodeEntryRawToNodeAndValue(0);
     expect(node0).toEqual([
       {
@@ -1343,11 +1362,11 @@ describe('BST operations map mode test', () => {
   });
 });
 
-describe('BST operations map mode test recursively', () => {
+describe('BST operations not map mode test recursively', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
     const bst = new BST<number>([], {
       iterationType: 'RECURSIVE',
-      isMapMode: true
+      isMapMode: false
     });
     expect(bst).toBeInstanceOf(BST);
     bst.add([11, 11]);
@@ -1375,7 +1394,7 @@ describe('BST operations map mode test recursively', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<number, { key: number; keyA: number }>([], { isMapMode: true });
+    const objBST = new BST<number, { key: number; keyA: number }>([], { isMapMode: false });
     expect(objBST).toBeInstanceOf(BST);
     objBST.add([11, { key: 11, keyA: 11 }]);
     objBST.add([3, { key: 3, keyA: 3 }]);
@@ -1429,7 +1448,7 @@ describe('BST operations map mode test recursively', () => {
   });
 });
 
-describe('BST iterative methods map mode test', () => {
+describe('BST iterative methods not map mode test', () => {
   let bst: BST<number, string>;
   beforeEach(() => {
     bst = new BST();