data-structure-typed 1.41.6 → 1.41.7

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

@@ -0,0 +1,49 @@
+import {DirectedGraph, UndirectedGraph} from '../../../../src';
+
+describe('Overall Graph Operation Test', () => {
+  it('Overall DirectedGraph Operation Test', () => {
+    const graph = new DirectedGraph();
+
+    graph.addVertex('A');
+    graph.addVertex('B');
+
+    graph.hasVertex('A'); // true
+    graph.hasVertex('B'); // true
+    graph.hasVertex('C'); // false
+    expect(graph.hasVertex('A')).toBe(true); // true
+    expect(graph.hasVertex('B')).toBe(true); // true
+    expect(graph.hasVertex('C')).toBe(false); // false
+
+    graph.addEdge('A', 'B');
+    graph.hasEdge('A', 'B'); // true
+    graph.hasEdge('B', 'A'); // false
+    expect(graph.hasEdge('A', 'B')).toBe(true); // true
+    expect(graph.hasEdge('B', 'A')).toBe(false); // false
+
+    graph.deleteEdgeSrcToDest('A', 'B');
+    graph.hasEdge('A', 'B'); // false
+    expect(graph.hasEdge('A', 'B')).toBe(false); // false
+
+    graph.addVertex('C');
+
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'C');
+
+    const topologicalOrderKeys = graph.topologicalSort();
+    expect(topologicalOrderKeys).toEqual(['A', 'B', 'C']);
+  });
+  it('Overall UndirectedGraph Operation Test', () => {
+    const graph = new UndirectedGraph();
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+    graph.deleteVertex('C');
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'D');
+
+    const dijkstraResult = graph.dijkstra('A');
+    Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.key); // ['A', 'B', 'D']
+    expect(Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.key)).toEqual(['A', 'B', 'D']);
+  });
+});

package/test/unit/data-structures/graph/salty-edges.json

@@ -0,0 +1 @@
+[[{"name":"Intersection_1"},{"name":"Intersection_2","weight":28}],[{"name":"Intersection_1"},{"name":"Intersection_14","weight":44}],[{"name":"Intersection_2"},{"name":"Intersection_3","weight":8}],[{"name":"Intersection_2"},{"name":"Intersection_14","weight":44}],[{"name":"Intersection_3"},{"name":"Intersection_4","weight":31}],[{"name":"Intersection_3"},{"name":"Intersection_22","weight":45}],[{"name":"Intersection_4"},{"name":"Intersection_5","weight":37}],[{"name":"Intersection_4"},{"name":"Intersection_24","weight":40}],[{"name":"Intersection_5"},{"name":"Intersection_6","weight":32}],[{"name":"Intersection_5"},{"name":"Intersection_26","weight":34}],[{"name":"Intersection_6"},{"name":"Intersection_7","weight":30}],[{"name":"Intersection_7"},{"name":"Intersection_8","weight":53}],[{"name":"Intersection_7"},{"name":"Intersection_27","weight":0}],[{"name":"Intersection_8"},{"name":"Intersection_9","weight":33}],[{"name":"Intersection_8"},{"name":"Intersection_47","weight":38}],[{"name":"Intersection_9"},{"name":"Intersection_10","weight":28}],[{"name":"Intersection_9"},{"name":"Intersection_62","weight":31}],[{"name":"Intersection_10"},{"name":"Intersection_11","weight":18}],[{"name":"Intersection_10"},{"name":"Intersection_59","weight":45}],[{"name":"Intersection_11"},{"name":"Intersection_12","weight":28}],[{"name":"Intersection_11"},{"name":"Intersection_58","weight":21}],[{"name":"Intersection_12"},{"name":"Intersection_13","weight":35}],[{"name":"Intersection_12"},{"name":"Intersection_57","weight":22}],[{"name":"Intersection_14"},{"name":"Intersection_15","weight":40}],[{"name":"Intersection_15"},{"name":"Intersection_16","weight":43}],[{"name":"Intersection_15"},{"name":"Intersection_23","weight":27}],[{"name":"Intersection_16"},{"name":"Intersection_17","weight":14}],[{"name":"Intersection_17"},{"name":"Intersection_18","weight":51}],[{"name":"Intersection_18"},{"name":"Intersection_19","weight":29}],[{"name":"Intersection_19"},{"name":"Intersection_20","weight":34}],[{"name":"Intersection_20"},{"name":"Intersection_21","weight":43}],[{"name":"Intersection_20"},{"name":"Intersection_66","weight":24}],[{"name":"Intersection_21"},{"name":"Intersection_52","weight":36}],[{"name":"Intersection_22"},{"name":"Intersection_23","weight":27}],[{"name":"Intersection_23"},{"name":"Intersection_33","weight":10}],[{"name":"Intersection_24"},{"name":"Intersection_25","weight":24}],[{"name":"Intersection_24"},{"name":"Intersection_22","weight":45}],[{"name":"Intersection_25"},{"name":"Intersection_34","weight":23}],[{"name":"Intersection_26"},{"name":"Intersection_30","weight":5}],[{"name":"Intersection_27"},{"name":"Intersection_28","weight":25}],[{"name":"Intersection_27"},{"name":"Intersection_45","weight":6}],[{"name":"Intersection_28"},{"name":"Intersection_29","weight":21}],[{"name":"Intersection_29"},{"name":"Intersection_26","weight":34}],[{"name":"Intersection_29"},{"name":"Intersection_41","weight":23}],[{"name":"Intersection_30"},{"name":"Intersection_24","weight":40}],[{"name":"Intersection_30"},{"name":"Intersection_31","weight":18}],[{"name":"Intersection_31"},{"name":"Intersection_32","weight":11}],[{"name":"Intersection_32"},{"name":"Intersection_35","weight":21}],[{"name":"Intersection_33"},{"name":"Intersection_25","weight":24}],[{"name":"Intersection_33"},{"name":"Intersection_42","weight":32}],[{"name":"Intersection_34"},{"name":"Intersection_32","weight":11}],[{"name":"Intersection_34"},{"name":"Intersection_42","weight":32}],[{"name":"Intersection_35"},{"name":"Intersection_36","weight":25}],[{"name":"Intersection_35"},{"name":"Intersection_43","weight":23}],[{"name":"Intersection_36"},{"name":"Intersection_37","weight":37}],[{"name":"Intersection_37"},{"name":"Intersection_49","weight":19}],[{"name":"Intersection_38"},{"name":"Intersection_39","weight":29}],[{"name":"Intersection_38"},{"name":"Intersection_46","weight":31}],[{"name":"Intersection_39"},{"name":"Intersection_40","weight":22}],[{"name":"Intersection_39"},{"name":"Intersection_46","weight":31}],[{"name":"Intersection_40"},{"name":"Intersection_41","weight":23}],[{"name":"Intersection_41"},{"name":"Intersection_31","weight":18}],[{"name":"Intersection_42"},{"name":"Intersection_16","weight":43}],[{"name":"Intersection_42"},{"name":"Intersection_43","weight":23}],[{"name":"Intersection_43"},{"name":"Intersection_44","weight":23}],[{"name":"Intersection_43"},{"name":"Intersection_17","weight":14}],[{"name":"Intersection_45"},{"name":"Intersection_39","weight":29}],[{"name":"Intersection_46"},{"name":"Intersection_48","weight":4}],[{"name":"Intersection_47"},{"name":"Intersection_38","weight":0}],[{"name":"Intersection_47"},{"name":"Intersection_45","weight":6}],[{"name":"Intersection_48"},{"name":"Intersection_37","weight":37}],[{"name":"Intersection_48"},{"name":"Intersection_63","weight":38}],[{"name":"Intersection_49"},{"name":"Intersection_19","weight":29}],[{"name":"Intersection_49"},{"name":"Intersection_51","weight":42}],[{"name":"Intersection_50"},{"name":"Intersection_49","weight":19}],[{"name":"Intersection_51"},{"name":"Intersection_66","weight":24}],[{"name":"Intersection_52"},{"name":"Intersection_53","weight":31}],[{"name":"Intersection_53"},{"name":"Intersection_54","weight":42}],[{"name":"Intersection_54"},{"name":"Intersection_55","weight":18}],[{"name":"Intersection_54"},{"name":"Intersection_61","weight":28}],[{"name":"Intersection_55"},{"name":"Intersection_56","weight":15}],[{"name":"Intersection_56"},{"name":"Intersection_13","weight":35}],[{"name":"Intersection_57"},{"name":"Intersection_56","weight":15}],[{"name":"Intersection_58"},{"name":"Intersection_57","weight":22}],[{"name":"Intersection_58"},{"name":"Intersection_65","weight":19}],[{"name":"Intersection_59"},{"name":"Intersection_60","weight":40}],[{"name":"Intersection_59"},{"name":"Intersection_62","weight":31}],[{"name":"Intersection_60"},{"name":"Intersection_53","weight":31}],[{"name":"Intersection_61"},{"name":"Intersection_59","weight":45}],[{"name":"Intersection_62"},{"name":"Intersection_47","weight":38}],[{"name":"Intersection_62"},{"name":"Intersection_63","weight":38}],[{"name":"Intersection_63"},{"name":"Intersection_64","weight":16}],[{"name":"Intersection_64"},{"name":"Intersection_60","weight":40}],[{"name":"Intersection_64"},{"name":"Intersection_51","weight":42}],[{"name":"Intersection_65"},{"name":"Intersection_61","weight":28}],[{"name":"Intersection_65"},{"name":"Intersection_55","weight":18}],[{"name":"Intersection_66"},{"name":"Intersection_52","weight":36}]]

package/test/unit/data-structures/graph/salty-vertexes.json

@@ -0,0 +1 @@
+[{"name":"Intersection_1"},{"name":"Intersection_2"},{"name":"Intersection_3"},{"name":"Intersection_4"},{"name":"Intersection_5"},{"name":"Intersection_6"},{"name":"Intersection_7"},{"name":"Intersection_8"},{"name":"Intersection_9"},{"name":"Intersection_10"},{"name":"Intersection_11"},{"name":"Intersection_12"},{"name":"Intersection_13"},{"name":"Intersection_14"},{"name":"Intersection_15"},{"name":"Intersection_16"},{"name":"Intersection_17"},{"name":"Intersection_18"},{"name":"Intersection_19"},{"name":"Intersection_20"},{"name":"Intersection_21"},{"name":"Intersection_22"},{"name":"Intersection_23"},{"name":"Intersection_24"},{"name":"Intersection_25"},{"name":"Intersection_26"},{"name":"Intersection_27"},{"name":"Intersection_28"},{"name":"Intersection_29"},{"name":"Intersection_30"},{"name":"Intersection_31"},{"name":"Intersection_32"},{"name":"Intersection_33"},{"name":"Intersection_34"},{"name":"Intersection_35"},{"name":"Intersection_36"},{"name":"Intersection_37"},{"name":"Intersection_38"},{"name":"Intersection_39"},{"name":"Intersection_40"},{"name":"Intersection_41"},{"name":"Intersection_42"},{"name":"Intersection_43"},{"name":"Intersection_44"},{"name":"Intersection_45"},{"name":"Intersection_46"},{"name":"Intersection_47"},{"name":"Intersection_48"},{"name":"Intersection_49"},{"name":"Intersection_50"},{"name":"Intersection_51"},{"name":"Intersection_52"},{"name":"Intersection_53"},{"name":"Intersection_54"},{"name":"Intersection_55"},{"name":"Intersection_56"},{"name":"Intersection_57"},{"name":"Intersection_58"},{"name":"Intersection_59"},{"name":"Intersection_60"},{"name":"Intersection_61"},{"name":"Intersection_62"},{"name":"Intersection_63"},{"name":"Intersection_64"},{"name":"Intersection_65"},{"name":"Intersection_66"}]

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

@@ -0,0 +1,168 @@
+import {UndirectedEdge, UndirectedGraph, UndirectedVertex} from '../../../../src';
+import saltyVertexes  from './SaltyGateStreetIntersections.json';
+import saltyEdges  from './SaltyGateStreetConnections.json';
+
+describe('UndirectedGraph Operation Test', () => {
+  let graph: UndirectedGraph;
+
+  beforeEach(() => {
+    graph = new UndirectedGraph();
+  });
+
+  it('should edge cases', () => {
+    expect(graph.deleteEdge(new UndirectedEdge('c', 'd'))).toBe(null);
+    expect(graph.deleteEdgeBetween('c', 'd')).toBe(null);
+    expect(graph.degreeOf('c')).toBe(0);
+    expect(graph.edgesOf('c').length).toBe(0);
+    expect(graph.getEndsOfEdge(new UndirectedEdge('c', 'd'))).toBe(null);
+  });
+
+  it('should add vertices', () => {
+    const vertex1 = new UndirectedVertex('A');
+    const vertex2 = new UndirectedVertex('B');
+
+    graph.addVertex(vertex1);
+    graph.addVertex(vertex2);
+
+    expect(graph.hasVertex(vertex1)).toBe(true);
+    expect(graph.hasVertex(vertex2)).toBe(true);
+  });
+
+  it('should add edges', () => {
+    const vertex1 = new UndirectedVertex('A');
+    const vertex2 = new UndirectedVertex('B');
+    const edge = new UndirectedEdge('A', 'B');
+
+    graph.addVertex(vertex1);
+    graph.addVertex(vertex2);
+    graph.addEdge(edge);
+
+    expect(graph.hasEdge('A', 'B')).toBe(true);
+    expect(graph.hasEdge('B', 'A')).toBe(true);
+  });
+
+  it('should delete edges', () => {
+    const vertex1 = new UndirectedVertex('A');
+    const vertex2 = new UndirectedVertex('B');
+    const edge = new UndirectedEdge('A', 'B');
+
+    graph.addVertex(vertex1);
+    graph.addVertex(vertex2);
+    graph.addEdge(edge);
+
+    expect(graph.deleteEdge(edge)).toBe(edge);
+    expect(graph.hasEdge('A', 'B')).toBe(false);
+  });
+
+  it('should perform topological sort', () => {
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+    graph.deleteVertex('C');
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'D');
+
+    const dijkstraResult = graph.dijkstra('A');
+    expect(Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.key)).toEqual(['A', 'B', 'D']);
+  });
+});
+
+describe('UndirectedGraph', () => {
+  let undirectedGraph: UndirectedGraph<string, string>;
+
+  beforeEach(() => {
+    // Create a new UndirectedGraph instance before each test
+    undirectedGraph = new UndirectedGraph<string, string>();
+  });
+
+  // Test adding vertices to the graph
+  it('should add vertices to the graph', () => {
+    const vertexA = new UndirectedVertex('A', 'Location A');
+    const vertexB = new UndirectedVertex('B', 'Location B');
+
+    undirectedGraph.addVertex(vertexA);
+    undirectedGraph.addVertex(vertexB);
+
+    expect(undirectedGraph.hasVertex('A')).toBe(true);
+    expect(undirectedGraph.hasVertex('B')).toBe(true);
+  });
+
+  // Test adding edges to the graph
+  it('should add edges to the graph', () => {
+    const vertexA = new UndirectedVertex('A', 'Location A');
+    const vertexB = new UndirectedVertex('B', 'Location B');
+    const edgeAB = new UndirectedEdge('A', 'B', 1, 'Edge between A and B');
+
+    undirectedGraph.addVertex(vertexA);
+    undirectedGraph.addVertex(vertexB);
+    undirectedGraph.addEdge(edgeAB);
+
+    expect(undirectedGraph.hasEdge('A', 'B')).toBe(true);
+  });
+
+  // Test getting neighbors of a vertex
+  it('should return the neighbors of a vertex', () => {
+    const vertexA = new UndirectedVertex('A', 'Location A');
+    const vertexB = new UndirectedVertex('B', 'Location B');
+    const vertexC = new UndirectedVertex('C', 'Location C');
+    const edgeAB = new UndirectedEdge('A', 'B', 1, 'Edge between A and B');
+    const edgeBC = new UndirectedEdge('B', 'C', 2, 'Edge between B and C');
+
+    undirectedGraph.addVertex(vertexA);
+    undirectedGraph.addVertex(vertexB);
+    undirectedGraph.addVertex(vertexC);
+    undirectedGraph.addEdge(edgeAB);
+    undirectedGraph.addEdge(edgeBC);
+
+    const neighborsOfA = undirectedGraph.getNeighbors('A');
+    const neighborsOfB = undirectedGraph.getNeighbors('B');
+
+    expect(neighborsOfA).toEqual([vertexB]);
+    expect(neighborsOfB).toEqual([vertexA, vertexC]);
+  });
+
+  // Test degree of a vertex
+  it('should return the degree of a vertex', () => {
+    const vertexA = new UndirectedVertex('A', 'Location A');
+    const vertexB = new UndirectedVertex('B', 'Location B');
+    const vertexC = new UndirectedVertex('C', 'Location C');
+    const edgeAB = new UndirectedEdge('A', 'B', 3, 'Edge between A and B');
+    const edgeBC = new UndirectedEdge('B', 'C', 4, 'Edge between B and C');
+
+    edgeAB.vertices = edgeAB.vertices;
+    expect(undirectedGraph.edges.size).toBe(0);
+    undirectedGraph.addVertex(vertexA);
+    undirectedGraph.addVertex(vertexB);
+    undirectedGraph.addVertex(vertexC);
+    undirectedGraph.addEdge(edgeAB);
+    undirectedGraph.addEdge(edgeBC);
+
+    const degreeOfA = undirectedGraph.degreeOf('A');
+    const degreeOfB = undirectedGraph.degreeOf('B');
+    const degreeOfC = undirectedGraph.degreeOf('C');
+    expect(undirectedGraph.edgeSet().length).toBe(2);
+    expect(undirectedGraph.getEndsOfEdge(edgeBC)?.length).toBe(2);
+
+    expect(degreeOfA).toBe(1);
+    expect(degreeOfB).toBe(2);
+    expect(degreeOfC).toBe(1);
+  });
+
+  it('xxx', () => {
+    // const start = performance.now();
+    const graph = new UndirectedGraph<{ name: string }, number >()
+    for (const v of saltyVertexes) {
+      graph.addVertex(v.name, v);
+    }
+    for (const e of saltyEdges) {
+      const [s,d] = e;
+      graph.addEdge( s.name, d.name, d.weight );
+    }
+    // const result = graph.getAllPathsBetween('Intersection_1','Intersection_5');
+    // console.log('---xxx', performance.now() - start, result)
+    // const result = graph.dijkstra('Intersection_1','Intersection_5', true, true);
+    // console.log('---xxx', performance.now() - start, result)
+
+  })
+});

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

@@ -0,0 +1,74 @@
+import {CoordinateMap} from '../../../../src';
+
+describe('CoordinateMap', () => {
+  it('should set and get values correctly', () => {
+    const coordinateMap = new CoordinateMap<string>();
+    const key = [1, 2, 3];
+    const value = 'TestValue';
+
+    coordinateMap.set(key, value);
+    const retrievedValue = coordinateMap.get(key);
+
+    expect(retrievedValue).toBe(value);
+  });
+
+  it('should return true when key exists', () => {
+    const coordinateMap = new CoordinateMap<string>();
+    const key = [1, 2, 3];
+    const value = 'TestValue';
+
+    coordinateMap.set(key, value);
+
+    expect(coordinateMap.has(key)).toBe(true);
+  });
+
+  it('should return false when key does not exist', () => {
+    const coordinateMap = new CoordinateMap<string>();
+    const key = [1, 2, 3];
+
+    expect(coordinateMap.has(key)).toBe(false);
+  });
+
+  it('should delete key-value pair correctly', () => {
+    const coordinateMap = new CoordinateMap<string>();
+    const key = [1, 2, 3];
+    const value = 'TestValue';
+
+    coordinateMap.set(key, value);
+    coordinateMap.delete(key);
+
+    expect(coordinateMap.has(key)).toBe(false);
+  });
+
+  it('should allow changing the joint character', () => {
+    const coordinateMap = new CoordinateMap<string>();
+    const key = [1, 2, 3];
+    const value = 'TestValue';
+
+    coordinateMap.set(key, value);
+    const newKey = [1, 2, 3];
+    const retrievedValue = coordinateMap.get(newKey);
+
+    expect(retrievedValue).toBe(value);
+  });
+});
+
+describe('CoordinateMap', () => {
+  class MyCoordinateMap<V = any> extends CoordinateMap<V> {
+    constructor(joint?: string) {
+      super(joint);
+      this._joint = joint += '-';
+    }
+  }
+
+  const cMap = new MyCoordinateMap<number>('*');
+
+  beforeEach(() => {
+    cMap.set([0, 0], 0);
+    cMap.set([0, 1], 1);
+    cMap.set([1, 1], 11);
+  });
+  it('should joint to be *-', () => {
+    expect(cMap.joint).toBe('*-');
+  });
+});

package/test/unit/data-structures/hash/coordinate-set.test.ts

@@ -0,0 +1,66 @@
+import {CoordinateSet} from '../../../../src';
+
+describe('CoordinateSet', () => {
+  it('should add and check values correctly', () => {
+    const coordinateSet = new CoordinateSet();
+    const value = [1, 2, 3];
+
+    coordinateSet.add(value);
+    const hasValue = coordinateSet.has(value);
+
+    expect(hasValue).toBe(true);
+  });
+
+  it('should return false when value does not exist', () => {
+    const coordinateSet = new CoordinateSet();
+    const value = [1, 2, 3];
+
+    expect(coordinateSet.has(value)).toBe(false);
+  });
+
+  it('should delete value correctly', () => {
+    const coordinateSet = new CoordinateSet();
+    const value = [1, 2, 3];
+
+    coordinateSet.add(value);
+    coordinateSet.delete(value);
+
+    expect(coordinateSet.has(value)).toBe(false);
+  });
+
+  it('should allow changing the joint character', () => {
+    const coordinateSet = new CoordinateSet();
+    const value = [1, 2, 3];
+
+    coordinateSet.add(value);
+    const newValue = [1, 2, 3];
+    const hasValue = coordinateSet.has(newValue);
+
+    expect(hasValue).toBe(true);
+  });
+});
+
+describe('MyCoordinateSet', () => {
+  class MyCoordinateSet extends CoordinateSet {
+    constructor(joint?: string) {
+      super(joint);
+      this._joint = joint += '-';
+    }
+  }
+
+  const mySet = new MyCoordinateSet('*');
+
+  beforeEach(() => {
+    mySet.add([0, 0]);
+    mySet.add([0, 1]);
+    mySet.add([1, 1]);
+  });
+  it('should joint to be *-', () => {
+    expect(mySet.joint).toBe('*-');
+  });
+
+  it('should has, delete', () => {
+    mySet.delete([0, 1]);
+    expect(mySet.has([0, 1])).toBe(false);
+  });
+});

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

@@ -0,0 +1,103 @@
+import {HashMap} from '../../../../src';
+
+describe('HashMap', () => {
+  let hashMap: HashMap<string, number>;
+
+  beforeEach(() => {
+    hashMap = new HashMap<string, number>();
+  });
+
+  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.isEmpty()).toBe(true);
+  });
+
+  it('should put and get values', () => {
+    hashMap.set('one', 1);
+    hashMap.set('two', 2);
+    hashMap.set('three', 3);
+
+    expect(hashMap.get('one')).toBe(1);
+    expect(hashMap.get('two')).toBe(2);
+    expect(hashMap.get('three')).toBe(3);
+  });
+
+  it('should handle key collisions', () => {
+    // Force a collision by setting two different keys to the same bucket
+    hashMap.set('key1', 1);
+    hashMap.set('key2', 2);
+
+    expect(hashMap.get('key1')).toBe(1);
+    expect(hashMap.get('key2')).toBe(2);
+  });
+
+  it('should delete values', () => {
+    hashMap.set('one', 1);
+    hashMap.set('two', 2);
+
+    hashMap.delete('one');
+    expect(hashMap.get('one')).toBeUndefined();
+    expect(hashMap.size).toBe(1);
+  });
+
+  it('should clear the HashMap', () => {
+    hashMap.set('one', 1);
+    hashMap.set('two', 2);
+
+    hashMap.clear();
+    expect(hashMap.size).toBe(0);
+    expect(hashMap.isEmpty()).toBe(true);
+  });
+
+  it('should iterate over entries', () => {
+    hashMap.set('one', 1);
+    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]
+      ])
+    );
+  });
+
+  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.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.get('one')).toBe(1);
+    expect(hashMap.get('two')).toBe(2);
+    expect(hashMap.get('three')).toBe(3);
+    expect(hashMap.get('four')).toBe(4);
+  });
+
+  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.set('one', 1);
+    hashMap.set('two', 2);
+
+    expect(hashMap.get('one')).toBe(1);
+    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);
+  });
+});

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

@@ -0,0 +1,186 @@
+import {HashTable, HashTableNode} from '../../../../src';
+
+describe('HashNode', () => {
+  it('should create a HashNode with key and value', () => {
+    const key = 'testKey';
+    const value = 'testValue';
+    const hashNode = new HashTableNode(key, value);
+
+    expect(hashNode.key).toBe(key);
+    expect(hashNode.value).toBe(value);
+    expect(hashNode.next).toBe(null);
+  });
+});
+
+describe('HashTable', () => {
+  it('should initialize with default capacity', () => {
+    const hashTable = new HashTable<string, string>();
+    expect(hashTable.capacity).toBe(16);
+    expect(hashTable.buckets).toEqual(new Array(16).fill(null));
+    expect(hashTable.hashFn('a')).toBe(6);
+    expect(hashTable.capacity).toBe(16);
+    expect(hashTable.size).toBe(0);
+    expect(hashTable.buckets.length).toBe(16);
+  });
+
+  it('should initialize with custom capacity', () => {
+    const customCapacity = 500;
+    const hashTable = new HashTable<string, string>(customCapacity);
+
+    expect(hashTable.capacity).toBe(customCapacity);
+    expect(hashTable.size).toBe(0);
+    expect(hashTable.buckets.length).toBe(customCapacity);
+  });
+
+  it('should put and get values correctly', () => {
+    const hashTable = new HashTable<string, string>();
+    const key = 'testKey';
+    const value = 'testValue';
+
+    hashTable.set(key, value);
+    const retrievedValue = hashTable.get(key);
+
+    expect(retrievedValue).toBe(value);
+  });
+
+  it('should handle collisions by chaining', () => {
+    const hashTable = new HashTable<string, string>();
+    const key1 = 'testKey1';
+    const value1 = 'testValue1';
+    const key2 = 'testKey2';
+    const value2 = 'testValue2';
+
+    hashTable.set(key1, value1);
+    hashTable.set(key2, value2);
+
+    const retrievedValue1 = hashTable.get(key1);
+    const retrievedValue2 = hashTable.get(key2);
+
+    expect(retrievedValue1).toBe(value1);
+    expect(retrievedValue2).toBe(value2);
+  });
+
+  it('should update value for an existing key', () => {
+    const hashTable = new HashTable<string, string>();
+    const key = 'testKey';
+    const initialValue = 'testValue1';
+    const updatedValue = 'testValue2';
+
+    hashTable.set(key, initialValue);
+    hashTable.set(key, updatedValue);
+
+    const retrievedValue = hashTable.get(key);
+
+    expect(retrievedValue).toBe(updatedValue);
+  });
+
+  it('should return undefined for non-existent key', () => {
+    const hashTable = new HashTable<string, string>();
+    const key = 'nonExistentKey';
+
+    const retrievedValue = hashTable.get(key);
+
+    expect(retrievedValue).toBeUndefined();
+  });
+
+  it('should delete key-value pair correctly', () => {
+    const hashTable = new HashTable<string, string>();
+    const key = 'testKey';
+    const value = 'testValue';
+
+    hashTable.set(key, value);
+    hashTable.delete(key);
+
+    const retrievedValue = hashTable.get(key);
+
+    expect(retrievedValue).toBeUndefined();
+    expect(hashTable.size).toBe(0);
+  });
+});
+
+describe('HashTable', () => {
+  let hashTable: HashTable<string, number>;
+
+  beforeEach(() => {
+    hashTable = new HashTable<string, number>();
+  });
+
+  it('should insert and retrieve values correctly', () => {
+    hashTable.set('one', 1);
+    hashTable.set('two', 2);
+
+    expect(hashTable.get('one')).toBe(1);
+    expect(hashTable.get('two')).toBe(2);
+  });
+
+  it('should update values correctly', () => {
+    hashTable.set('one', 1);
+    expect(hashTable.get('one')).toBe(1);
+
+    hashTable.set('one', 100); // Update the value
+    expect(hashTable.get('one')).toBe(100);
+  });
+
+  it('should handle collisions correctly', () => {
+    hashTable = new HashTable<string, number>(1); // Set a small capacity to force collisions
+    hashTable.set('one', 1);
+    hashTable.set('two', 2);
+
+    expect(hashTable.get('one')).toBe(1);
+    expect(hashTable.get('two')).toBe(2);
+  });
+
+  it('should delete values correctly', () => {
+    hashTable.set('one', 1);
+    hashTable.set('two', 2);
+    hashTable.delete('one');
+
+    expect(hashTable.get('one')).toBeUndefined();
+    expect(hashTable.get('two')).toBe(2);
+  });
+
+  it('should handle non-existent keys correctly', () => {
+    expect(hashTable.get('non-existent')).toBeUndefined();
+    hashTable.delete('non-existent'); // Removing a non-existent key should not cause errors
+  });
+
+  it('should handle custom hash function correctly', () => {
+    // const customHashFn = () => {
+    //   // Custom hash function that returns a fixed value for all keys
+    //   return 42;
+    // };
+
+    hashTable = new HashTable<string, number>(16);
+    hashTable.set('one', 1);
+    expect(hashTable.get('one')).toBe(1);
+    expect(hashTable.get('two')).toBeUndefined();
+  });
+
+  it('should expand when load factor exceeds threshold', () => {
+    hashTable = new HashTable<string, number>(2); // Set a small capacity to trigger expansion
+    hashTable.set('one', 1);
+    hashTable.set('two', 2);
+    hashTable.set('three', 3); // This should trigger an expansion
+
+    expect(hashTable.capacity).toBe(16);
+    expect(hashTable.get('one')).toBe(1);
+    expect(hashTable.get('two')).toBe(2);
+    expect(hashTable.get('three')).toBe(3);
+  });
+});
+
+describe('HashTable performance', function () {
+  it('Items set performance', function () {
+    const mag = 100000;
+    const ht = new HashTable();
+    // const s = performance.now();
+    for (let i = 0; i < mag; i++) {
+      ht.set(i, i);
+    }
+    // const s1 = performance.now();
+    const map = new Map();
+    for (let i = 0; i < mag; i++) {
+      map.set(i, i);
+    }
+  });
+});