data-structure-typed 1.44.0 → 1.45.0

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

@@ -1,8 +1,2 @@
 // 0 means unknown, 1 means visiting, 2 means visited;
 export type TopologicalStatus = 0 | 1 | 2;
-
-export enum TopologicalProperty {
-  VAL = 'VAL',
-  NODE = 'NODE',
-  ID = 'ID'
-}

package/src/types/data-structures/hash/hash-map.ts

@@ -1 +1,17 @@
-export {};
+export const enum IterateDirection {
+  DEFAULT = 0,
+  REVERSE = 1
+}
+
+export type HashMapOptions<T> = {
+  sizeFunction?: number | (() => number);
+  fixedLength?: number;
+  forEach: (callback: (el: T) => void) => void;
+}
+
+export type HashMapLinkedNode<K, V> = {
+  key: K
+  value: V
+  next: HashMapLinkedNode<K, V>
+  prev: HashMapLinkedNode<K, V>
+}

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

@@ -1 +1,8 @@
+export * from './coordinate-map';
+export * from './coordinate-set';
+export * from './hash-map';
+export * from './hash-table';
+export * from './tree-map';
+export * from './tree-set';
+
 export type HashFunction<K> = (key: K) => number;

package/src/utils/utils.ts

@@ -84,3 +84,16 @@ export const getMSB = (value: number): number => {
   }
   return 1 << (31 - Math.clz32(value));
 };
+
+export const rangeCheck = (index: number, min: number, max: number, message = 'Index out of bounds.'): void => {
+  if (index < min || index > max) throw new RangeError(message);
+}
+
+export const throwRangeError = (message = 'The value is off-limits.'): void => {
+  throw new RangeError(message);
+}
+
+export const isObjOrFunc = (input: unknown): input is Record<string, unknown> | ((...args: any[]) => any) => {
+  const inputType = typeof input;
+  return (inputType === 'object' && input !== null) || inputType === 'function';
+}

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

@@ -0,0 +1,110 @@
+import {AVLTree, CP} from 'data-structure-typed';
+
+describe('AVL Tree Test from data-structure-typed', () => {
+  it('should perform various operations on a AVL Tree from data-structure-typed', () => {
+    const keys = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    const tree = new AVLTree();
+
+    for (const i of keys) tree.add(i, i);
+
+    const node6 = tree.get(6);
+
+    expect(node6 && tree.getHeight(node6)).toBe(3);
+    expect(node6 && tree.getDepth(node6)).toBe(1);
+
+    const getValueById = tree.get(10);
+    expect(getValueById).toBe(10);
+
+    const getMinNodeByRoot = tree.getLeftMost();
+    expect(getMinNodeByRoot?.key).toBe(1);
+
+    const node15 = tree.getNode(15);
+    const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
+    expect(getMinNodeBySpecificNode?.key).toBe(12);
+
+    let subTreeSum = 0;
+    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), 15);
+    expect(subTreeSum).toBe(70);
+
+    let lesserSum = 0;
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.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');
+    expect(dfs[0].key).toBe(1);
+    expect(dfs[dfs.length - 1].key).toBe(16);
+
+    tree.perfectlyBalance();
+    const bfs = tree.bfs(node => node);
+    expect(tree.isPerfectlyBalanced()).toBe(true);
+    expect(bfs[0].key).toBe(8);
+    expect(bfs[bfs.length - 1].key).toBe(16);
+
+    expect(tree.delete(11)[0].deleted?.key).toBe(11);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(node15 && tree.getHeight(node15)).toBe(2);
+
+    expect(tree.delete(1)[0].deleted?.key).toBe(1);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+
+    expect(tree.delete(4)[0].deleted?.key).toBe(4);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+
+    expect(tree.delete(10)[0].deleted?.key).toBe(10);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(15)[0].deleted?.key).toBe(15);
+    expect(tree.isAVLBalanced()).toBe(true);
+
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(5)[0].deleted?.key).toBe(5);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(13)[0].deleted?.key).toBe(13);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(3)[0].deleted?.key).toBe(3);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(8)[0].deleted?.key).toBe(8);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(6)[0].deleted?.key).toBe(6);
+    expect(tree.delete(6).length).toBe(0);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+
+    expect(tree.delete(7)[0].deleted?.key).toBe(7);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+
+    expect(tree.delete(9)[0].deleted?.key).toBe(9);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+    expect(tree.delete(14)[0].deleted?.key).toBe(14);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(1);
+
+    expect(tree.isAVLBalanced()).toBe(true);
+    const lastBFSIds = tree.bfs();
+    expect(lastBFSIds[0]).toBe(12);
+    expect(lastBFSIds[1]).toBe(2);
+    expect(lastBFSIds[2]).toBe(16);
+
+    const lastBFSNodes = tree.bfs(node => node);
+    expect(lastBFSNodes[0].key).toBe(12);
+    expect(lastBFSNodes[1].key).toBe(2);
+    expect(lastBFSNodes[2].key).toBe(16);
+  });
+});

package/test/performance/reportor.ts

@@ -107,7 +107,7 @@ const composeReport = () => {
     htmlTables // New content to be inserted
   );
   fs.writeFileSync(htmlFilePath, html);
-  console.log(`Performance ${BOLD}${GREEN}report${END} file generated`);
+  console.log(`Performance ${BOLD}${GREEN}report${END} file generated in ${BOLD}${GREEN}${reportDistPath}${END}`);
 };
 
 function replaceMarkdownContent(startMarker: string, endMarker: string, newText: string) {
@@ -135,7 +135,7 @@ function replaceMarkdownContent(startMarker: string, endMarker: string, newText:
       if (err) {
         console.error(`Unable to write to ${filePath}:`, err);
       } else {
-        console.log(`The content has been successfully replaced in ${filePath}!`);
+        console.log(`The content has been successfully replaced in ${BOLD}${GREEN}${filePath}!${END}`);
       }
     });
   });

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

@@ -219,7 +219,7 @@ describe('AVL Tree Test recursively', () => {
 });
 
 describe('AVLTree APIs test', () => {
-  const avl = new AVLTree<{id: number; text: string}>();
+  const avl = new AVLTree<{ id: number; text: string }>();
   beforeEach(() => {
     avl.clear();
   });
@@ -268,7 +268,7 @@ describe('AVLTree', () => {
   });
 
   describe('BinaryTree APIs test', () => {
-    const avl = new AVLTree<{id: number; text: string}>();
+    const avl = new AVLTree<{ id: number; text: string }>();
     beforeEach(() => {
       avl.clear();
     });

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

@@ -189,7 +189,7 @@ describe('BST operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<{key: number; keyA: number}>();
+    const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});
@@ -260,7 +260,7 @@ describe('BST operations test', () => {
     objBST.perfectlyBalance();
     expect(objBST.isPerfectlyBalanced()).toBe(true);
 
-    const bfsNodesAfterBalanced: BSTNode<{key: number; keyA: number}>[] = [];
+    const bfsNodesAfterBalanced: BSTNode<{ key: number; keyA: number }>[] = [];
     objBST.bfs(node => bfsNodesAfterBalanced.push(node));
     expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
@@ -385,7 +385,7 @@ describe('BST operations test', () => {
     expect(bfsIDs[1]).toBe(12);
     expect(bfsIDs[2]).toBe(16);
 
-    const bfsNodes: BSTNode<{key: number; keyA: number}>[] = [];
+    const bfsNodes: BSTNode<{ key: number; keyA: number }>[] = [];
     objBST.bfs(node => bfsNodes.push(node));
     expect(bfsNodes[0].key).toBe(2);
     expect(bfsNodes[1].key).toBe(12);
@@ -580,7 +580,7 @@ describe('BST operations test recursively', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<{key: number; keyA: number}>();
+    const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});
@@ -652,7 +652,7 @@ describe('BST operations test recursively', () => {
     objBST.perfectlyBalance();
     expect(objBST.isPerfectlyBalanced()).toBe(true);
 
-    const bfsNodesAfterBalanced: BSTNode<{key: number; keyA: number}>[] = [];
+    const bfsNodesAfterBalanced: BSTNode<{ key: number; keyA: number }>[] = [];
     objBST.bfs(node => bfsNodesAfterBalanced.push(node));
     expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
@@ -777,7 +777,7 @@ describe('BST operations test recursively', () => {
     expect(bfsIDs[1]).toBe(12);
     expect(bfsIDs[2]).toBe(16);
 
-    const bfsNodes: BSTNode<{key: number; keyA: number}>[] = [];
+    const bfsNodes: BSTNode<{ key: number; keyA: number }>[] = [];
     objBST.bfs(node => bfsNodes.push(node));
     expect(bfsNodes[0].key).toBe(2);
     expect(bfsNodes[1].key).toBe(12);

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

@@ -29,7 +29,7 @@ describe('Overall BinaryTree Test', () => {
     bfsIDs[0] === 11; // true
     expect(bfsIDs[0]).toBe(11);
 
-    const objBST = new BST<{key: number; keyA: number}>();
+    const objBST = new BST<{ key: number; keyA: number }>();
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});
 

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

@@ -13,7 +13,7 @@ describe('RedBlackTree', () => {
   });
 
   describe('add and getNode', () => {
-    test('should add and find a node in the tree', () => {
+    it('should add and find a node in the tree', () => {
       tree.add(10);
       tree.add(20);
       tree.add(5);
@@ -24,7 +24,7 @@ describe('RedBlackTree', () => {
       expect(tree.getNode(15)).toBe(undefined);
     });
 
-    test('should add and find nodes with negative keys', () => {
+    it('should add and find nodes with negative keys', () => {
       tree.add(-10);
       tree.add(-20);
 
@@ -34,7 +34,7 @@ describe('RedBlackTree', () => {
   });
 
   describe('deleteNode', () => {
-    test('should delete a node from the tree', () => {
+    it('should delete a node from the tree', () => {
       tree.add(10);
       tree.add(20);
       tree.add(5);
@@ -43,7 +43,7 @@ describe('RedBlackTree', () => {
       expect(tree.getNode(20)).toBe(undefined);
     });
 
-    test('should handle deleting a non-existent node', () => {
+    it('should handle deleting a non-existent node', () => {
       tree.add(10);
       tree.add(20);
       tree.add(5);
@@ -54,7 +54,7 @@ describe('RedBlackTree', () => {
   });
 
   describe('minimum', () => {
-    test('should find the minimum node in the tree', () => {
+    it('should find the minimum node in the tree', () => {
       tree.add(10);
       tree.add(20);
       tree.add(5);
@@ -65,14 +65,14 @@ describe('RedBlackTree', () => {
       expect(minNode?.key).toBe(3);
     });
 
-    test('should handle an empty tree', () => {
+    it('should handle an empty tree', () => {
       const minNode = tree.getLeftMost(tree.root);
       expect(minNode).toBe(tree.NIL);
     });
   });
 
   describe('getRightMost', () => {
-    test('should find the getRightMost node in the tree', () => {
+    it('should find the getRightMost node in the tree', () => {
       tree.add(10);
       tree.add(20);
       tree.add(5);
@@ -83,14 +83,14 @@ describe('RedBlackTree', () => {
       expect(maxNode?.key).toBe(25);
     });
 
-    test('should handle an empty tree', () => {
+    it('should handle an empty tree', () => {
       const maxNode = tree.getRightMost(tree.root);
       expect(maxNode).toBe(tree.NIL);
     });
   });
 
   describe('getSuccessor', () => {
-    test('should find the getSuccessor of a node', () => {
+    it('should find the getSuccessor of a node', () => {
       tree.add(10);
       tree.add(20);
       tree.add(5);
@@ -103,7 +103,7 @@ describe('RedBlackTree', () => {
       expect(successorNode?.key).toBe(20);
     });
 
-    test('should handle a node with no getSuccessor', () => {
+    it('should handle a node with no getSuccessor', () => {
       tree.add(10);
       tree.add(5);
 
@@ -115,7 +115,7 @@ describe('RedBlackTree', () => {
   });
 
   describe('getPredecessor', () => {
-    test('should find the getPredecessor of a node', () => {
+    it('should find the getPredecessor of a node', () => {
       tree.add(10);
       tree.add(20);
       tree.add(5);
@@ -128,7 +128,7 @@ describe('RedBlackTree', () => {
       expect(predecessorNode?.key).toBe(15);
     });
 
-    test('should handle a node with no getPredecessor', () => {
+    it('should handle a node with no getPredecessor', () => {
       tree.add(10);
       tree.add(20);
 
@@ -478,13 +478,13 @@ describe('RedBlackTree', () => {
     for (let i = 0; i < arr.length; i++) {
       tree.add(arr[i]);
     }
-    console.log(performance.now() - tS);
+    isDebug && console.log(performance.now() - tS);
 
     const cS = performance.now();
 
     for (let i = 0; i < arr.length; i++) {
       competitor.setElement(arr[i], arr[i]);
     }
-    console.log(performance.now() - cS);
+    isDebug && console.log(performance.now() - cS);
   });
 });

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

@@ -207,7 +207,7 @@ describe('TreeMultimap operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultimap = new TreeMultimap<{key: number; keyA: number}>();
+    const objTreeMultimap = new TreeMultimap<{ key: number; keyA: number }>();
     expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
     objTreeMultimap.add(11, {key: 11, keyA: 11});
     objTreeMultimap.add(3, {key: 3, keyA: 3});
@@ -447,7 +447,7 @@ describe('TreeMultimap operations test recursively', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultimap = new TreeMultimap<{key: number; keyA: number}>();
+    const objTreeMultimap = new TreeMultimap<{ key: number; keyA: number }>();
     expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
     objTreeMultimap.add(11, {key: 11, keyA: 11});
     objTreeMultimap.add(3, {key: 3, keyA: 3});

package/test/unit/data-structures/graph/abstract-graph.test.ts

@@ -74,7 +74,8 @@ class MyGraph<V = any, E = any, VO extends MyVertex<V> = MyVertex<V>, EO extends
 describe('AbstractGraph Operation Test', () => {
   const myGraph: MyGraph<number, string> = new MyGraph<number, string>();
 
-  beforeEach(() => {});
+  beforeEach(() => {
+  });
   it('should edge cases', function () {
     myGraph.addVertex('A', 1);
     myGraph.addVertex('B', 2);

package/test/unit/data-structures/graph/undirected-graph.test.ts

@@ -150,7 +150,7 @@ describe('UndirectedGraph', () => {
   });
 
   it('should getAllPathsBetween work well in 66 vertexes 97 edges graph', () => {
-    const graph = new UndirectedGraph<{name: string}, number>();
+    const graph = new UndirectedGraph<{ name: string }, number>();
     for (const v of saltyVertexes) {
       graph.addVertex(v.name, v);
     }

package/test/unit/data-structures/hash/hash-map.test.ts

@@ -1,4 +1,6 @@
 import {HashMap} from '../../../../src';
+import {getRandomInt, getRandomIntArray} from "../../../utils";
+
 
 describe('HashMap', () => {
   let hashMap: HashMap<string, number>;
@@ -9,10 +11,10 @@ describe('HashMap', () => {
 
   it('should initialize correctly', () => {
     expect(hashMap.size).toBe(0);
-    expect(hashMap.table.length).toBe(16);
-    expect(hashMap.loadFactor).toBe(0.75);
-    expect(hashMap.capacityMultiplier).toBe(2);
-    expect(hashMap.initialCapacity).toBe(16);
+    // expect(hashMap.table.length).toBe(16);
+    // expect(hashMap.loadFactor).toBe(0.75);
+    // expect(hashMap.capacityMultiplier).toBe(2);
+    // expect(hashMap.initialCapacity).toBe(16);
     expect(hashMap.isEmpty()).toBe(true);
   });
 
@@ -58,26 +60,23 @@ describe('HashMap', () => {
     hashMap.set('two', 2);
     hashMap.set('three', 3);
 
-    const entries = Array.from(hashMap.entries());
-    expect(entries).toEqual(
-      expect.arrayContaining([
-        ['one', 1],
-        ['two', 2],
-        ['three', 3]
-      ])
-    );
+    // const entries = Array.from(hashMap.entries());
+    // expect(entries).toContainEqual(['one', 1]);
+    // expect(entries).toContainEqual(['two', 2]);
+    // expect(entries).toContainEqual(['three', 3]);
   });
 
+
   it('should resize the table when load factor is exceeded', () => {
     // Set a small initial capacity for testing resizing
-    hashMap = new HashMap<string, number>(4, 0.5);
+    hashMap = new HashMap<string, number>();
 
     hashMap.set('one', 1);
     hashMap.set('two', 2);
     hashMap.set('three', 3);
     hashMap.set('four', 4); // This should trigger a resize
 
-    expect(hashMap.table.length).toBe(8);
+    // expect(hashMap.table.length).toBe(8);
     expect(hashMap.get('one')).toBe(1);
     expect(hashMap.get('two')).toBe(2);
     expect(hashMap.get('three')).toBe(3);
@@ -85,11 +84,8 @@ describe('HashMap', () => {
   });
 
   it('should allow using a custom hash function', () => {
-    const customHashFn = () => {
-      // A simple custom hash function that always returns 0
-      return 0;
-    };
-    hashMap = new HashMap<string, number>(16, 0.75, customHashFn);
+
+    hashMap = new HashMap<string, number>();
 
     hashMap.set('one', 1);
     hashMap.set('two', 2);
@@ -98,6 +94,141 @@ describe('HashMap', () => {
     expect(hashMap.get('two')).toBe(2);
     // Since the custom hash function always returns 0, these keys will collide.
     // Make sure they are stored separately.
-    expect(hashMap.table[0].length).toBe(2);
+    // expect(hashMap.table[0].length).toBe(2);
   });
 });
+
+describe('HashMap', () => {
+  let hashMap: HashMap;
+
+  beforeEach(() => {
+    hashMap = new HashMap();
+  });
+
+  it('should create an empty map', () => {
+    expect(hashMap.size).toBe(0);
+  });
+
+  it('should add a key-value pair', () => {
+    hashMap.set('key1', 'value1');
+    expect(hashMap.get('key1')).toBe('value1');
+  });
+
+  it('should handle object keys correctly', () => {
+    const keyObj = {id: 1};
+    hashMap.set(keyObj, 'objectValue');
+    expect(hashMap.get(keyObj)).toBe('objectValue');
+  });
+
+  it('should handle number keys correctly', () => {
+    hashMap.set(999, {a: '999Value'});
+    expect(hashMap.get(999)).toEqual({a: '999Value'});
+  });
+
+  it('should update the value for an existing key', () => {
+    hashMap.set('key1', 'value1');
+    hashMap.set('key1', 'newValue');
+    expect(hashMap.get('key1')).toBe('newValue');
+  });
+
+  it('should return undefined for a non-existent key', () => {
+    expect(hashMap.get('nonExistentKey')).toBeUndefined();
+  });
+
+  it('should remove a key-value pair', () => {
+    hashMap.set('key1', 'value1');
+    hashMap.delete('key1');
+    expect(hashMap.get('key1')).toBeUndefined();
+  });
+
+  it('should clear the map', () => {
+    hashMap.set('key1', 'value1');
+    expect(hashMap.size).toBe(1);
+
+    hashMap.clear();
+    expect(hashMap.size).toBe(0);
+  });
+
+  it('should iterate over values', () => {
+    hashMap.set('key1', 'value1');
+    hashMap.set('key2', 'value2');
+    const values = [];
+    for (const value of hashMap) {
+      values.push(value);
+    }
+    expect(values).toEqual([['key1', 'value1'], ['key2', 'value2']]);
+  });
+
+  // test('should delete element at specific index', () => {
+  //   hashMap.set('key1', 'value1');
+  //   hashMap.set('key2', 'value2');
+  //   hashMap.deleteAt(0);
+  //   expect(hashMap.get('key1')).toBeUndefined();
+  //   expect(hashMap.size).toBe(1);
+  // });
+  function compareHashMaps(hashMap: HashMap<unknown, unknown>, stdMap: Map<unknown, unknown>) {
+    expect(hashMap.size).toEqual(stdMap.size);
+    let index = 0;
+    stdMap.forEach((value, key) => {
+      if (index === 0) {
+        expect(hashMap.front).toEqual([key, value]);
+        expect(hashMap.begin.current[0]).toEqual(key);
+      } else if (index === hashMap.size - 1) {
+        expect(hashMap.back).toEqual([key, value]);
+        expect(hashMap.reverseBegin.current[0]).toEqual(key);
+      } else if (index <= 1000) {
+        expect(hashMap.getAt(index)).toEqual([key, value]);
+      }
+      expect(hashMap.get(key)).toEqual(value);
+      expect(hashMap.getIterator(key).current[1]).toEqual(value);
+      index++;
+    });
+  }
+
+  const stdMap: Map<unknown, unknown> = new Map();
+  const arr: number[] = getRandomIntArray(1000, 1, 10000);
+
+  it('delete test', () => {
+    for (const item of arr) {
+      stdMap.set(item, item);
+      hashMap.set(item, item);
+    }
+    for (const item of arr) {
+      if (Math.random() > 0.6) {
+        expect(hashMap.delete(item)).toEqual(stdMap.delete(item));
+      }
+    }
+    compareHashMaps(hashMap, stdMap);
+
+    for (let i = 0; i < 1000; ++i) {
+      const random = getRandomInt(0, 100);
+      expect(hashMap.delete(random)).toEqual(stdMap.delete(random));
+    }
+    compareHashMaps(hashMap, stdMap);
+  });
+
+  test('should iterate correctly with reverse iterators', () => {
+    hashMap.set('key1', 'value1');
+    hashMap.set('key2', 'value2');
+    const iterator = hashMap.reverseBegin;
+    expect(iterator.next().current).toEqual(['key1', 'value1']);
+
+  });
+
+  test('should return the last element', () => {
+    hashMap.set('key1', 'value1');
+    hashMap.set('key2', 'value2');
+    expect(hashMap.back).toEqual(['key2', 'value2']);
+  });
+
+  test('should return undefined for empty map', () => {
+    expect(hashMap.back).toBeUndefined();
+  });
+
+  test('should get element at specific index', () => {
+    hashMap.set('key1', 'value1');
+    hashMap.set('key2', 'value2');
+    expect(hashMap.getAt(1)).toEqual(['key2', 'value2']);
+  });
+})
+