Add hash table

Author: NeurAlch

src/data-structures/hash-table.test.ts

@@ -0,0 +1,82 @@
+import { HashTable } from './hash-table';
+
+describe('HashTable', () => {
+  it('should create an instance', () => {
+    const hashTable = new HashTable<string, number>();
+    expect(hashTable).toBeInstanceOf(HashTable);
+    expect(hashTable.size()).toBe(0);
+    expect(hashTable.keys()).toEqual([]);
+    expect(hashTable.values()).toEqual([]);
+  });
+
+  it('should set and get values', () => {
+    const hashTable = new HashTable<string, number>();
+    hashTable.set('one', 1);
+    expect(hashTable.size()).toBe(1);
+    expect(hashTable.get('one')).toBe(1);
+    hashTable.set('two', 2);
+    expect(hashTable.size()).toBe(2);
+    expect(hashTable.get('two')).toBe(2);
+    hashTable.set('one', 10);
+    expect(hashTable.size()).toBe(2);
+    expect(hashTable.get('one')).toBe(10);
+  });
+
+  it('should remove values', () => {
+    const hashTable = new HashTable<string, number>();
+    hashTable.set('one', 1);
+    hashTable.set('two', 2);
+    expect(hashTable.size()).toBe(2);
+    hashTable.remove('one');
+    expect(hashTable.size()).toBe(1);
+    expect(hashTable.get('one')).toBeUndefined();
+    expect(hashTable.get('two')).toBe(2);
+  });
+
+  it('should check if key exists', () => {
+    const hashTable = new HashTable<string, number>();
+    hashTable.set('one', 1);
+    expect(hashTable.has('one')).toBe(true);
+    expect(hashTable.has('two')).toBe(false);
+  });
+
+  it('should clear the hash table', () => {
+    const hashTable = new HashTable<string, number>();
+    hashTable.set('one', 1);
+    hashTable.set('two', 2);
+    expect(hashTable.size()).toBe(2);
+    hashTable.clear();
+    expect(hashTable.size()).toBe(0);
+    expect(hashTable.get('one')).toBeUndefined();
+    expect(hashTable.get('two')).toBeUndefined();
+  });
+
+  it('should return all keys and values', () => {
+    const hashTable = new HashTable<string, number>();
+    hashTable.set('one', 1);
+    hashTable.set('two', 2);
+    hashTable.set('three', 3);
+    expect(hashTable.keys().sort()).toEqual(['one', 'three', 'two']);
+    expect(hashTable.values().sort()).toEqual([1, 2, 3]);
+  });
+
+  it('should increase the size when adding a new key', () => {
+    const hashTable = new HashTable<string, number>(1);
+    hashTable.set('one', 1);
+    hashTable.set('two', 2);
+    hashTable.set('three', 3);
+    expect(hashTable.size()).toBe(3);
+    expect(hashTable.get('one')).toBe(1);
+    expect(hashTable.get('two')).toBe(2);
+    expect(hashTable.get('three')).toBe(3);
+  });
+
+  it('should handle different key types', () => {
+    const hashTable = new HashTable<number | string, string>();
+    hashTable.set(1, 'one');
+    hashTable.set('two', 'two');
+    expect(hashTable.get(1)).toBe('one');
+    expect(hashTable.get('two')).toBe('two');
+    expect(hashTable.size()).toBe(2);
+  });
+});

src/data-structures/hash-table.ts

@@ -0,0 +1,83 @@
+export interface IHashTable<TKey, TValue> {
+  clear(): void;
+  size(): number;
+  keys(): TKey[];
+  values(): TValue[];
+  has(key: TKey): boolean;
+  remove(key: TKey): void;
+  set(key: TKey, value: TValue): void;
+  get(key: TKey): TValue | undefined;
+}
+
+export class HashTable<TKey, TValue> implements IHashTable<TKey, TValue> {
+  protected _size: number;
+  protected _buckets: Array<Array<[TKey, TValue]>>;
+
+  constructor(bucketSize = 16) {
+    this._size = 0;
+    this._buckets = new Array(bucketSize).fill(null).map(() => []);
+  }
+
+  protected hash(key: TKey): number {
+    const stringKey = String(key);
+
+    let total = 0;
+    for (let i = 0; i < stringKey.length; i++) {
+      total += stringKey.charCodeAt(i);
+    }
+
+    return total % this._buckets.length;
+  }
+
+  set(key: TKey, value: TValue): void {
+    const index = this.hash(key);
+    const bucket = this._buckets[index];
+    const item = bucket.find(([k]) => k === key);
+
+    if (item) {
+      item[1] = value;
+    } else {
+      bucket.push([key, value]);
+      this._size++;
+    }
+  }
+
+  get(key: TKey): TValue | undefined {
+    const index = this.hash(key);
+    const item = this._buckets[index].find(([k]) => k === key);
+    return item ? item[1] : undefined;
+  }
+
+  remove(key: TKey): void {
+    const index = this.hash(key);
+    const bucket = this._buckets[index];
+    const itemIndex = bucket.findIndex(([k]) => k === key);
+
+    if (itemIndex !== -1) {
+      bucket.splice(itemIndex, 1);
+      this._size--;
+    }
+  }
+
+  has(key: TKey): boolean {
+    const index = this.hash(key);
+    return this._buckets[index].some(([k]) => k === key);
+  }
+
+  clear(): void {
+    this._buckets = this._buckets.map(() => []);
+    this._size = 0;
+  }
+
+  size(): number {
+    return this._size;
+  }
+
+  keys(): TKey[] {
+    return this._buckets.flatMap((bucket) => bucket.map(([k]) => k));
+  }
+
+  values(): TValue[] {
+    return this._buckets.flatMap((bucket) => bucket.map(([, v]) => v));
+  }
+}