Implement the hash table data structure

Author: FSou1

src/data-structures/hash-table/README.md

@@ -0,0 +1,5 @@
+# Hash table
+
+In computing, a hash table (hash map) is a data structure that implements an associative array abstract data type, a structure that can map keys to values. A hash table uses a hash function to compute an index, also called a hash code, into an array of buckets or slots, from which the desired value can be found. During lookup, the key is hashed and the resulting hash indicates where the corresponding value is stored.
+
+Ideally, the hash function will assign each key to a unique bucket, but most hash table designs employ an imperfect hash function, which might cause hash collisions where the hash function generates the same index for more than one key. Such collisions are typically accommodated in some way.

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

@@ -0,0 +1,117 @@
+import { HashTable } from '../hashTable';
+
+describe('HashTable', () => {
+  it('should create hash table of certain size', () => {
+    const defaultHashTable = new HashTable();
+    expect(defaultHashTable.buckets.length).toBe(32);
+
+    const biggerHashTable = new HashTable(64);
+    expect(biggerHashTable.buckets.length).toBe(64);
+  });
+
+  it('should generate proper hash for specified keys', () => {
+    const hashTable = new HashTable();
+
+    expect(hashTable.hash('a')).toBe(1);
+    expect(hashTable.hash('b')).toBe(2);
+    expect(hashTable.hash('abc')).toBe(6);
+  });
+
+  it('should set, read and delete data with collisions', () => {
+    const hashTable = new HashTable(3);
+
+    expect(hashTable.hash('a')).toBe(1);
+    expect(hashTable.hash('b')).toBe(2);
+    expect(hashTable.hash('c')).toBe(0);
+    expect(hashTable.hash('d')).toBe(1);
+
+    hashTable.set('a', 'sky-old');
+    hashTable.set('a', 'sky');
+    hashTable.set('b', 'sea');
+    hashTable.set('c', 'earth');
+    hashTable.set('d', 'ocean');
+
+    expect(hashTable.has('x')).toBe(false);
+    expect(hashTable.has('b')).toBe(true);
+    expect(hashTable.has('c')).toBe(true);
+
+    const stringifier = (value) => `${value.key}:${value.value}`;
+
+    // expect(hashTable.buckets[0].toString(stringifier)).toBe('c:earth');
+    // expect(hashTable.buckets[1].toString(stringifier)).toBe('a:sky,d:ocean');
+    // expect(hashTable.buckets[2].toString(stringifier)).toBe('b:sea');
+
+    expect(hashTable.get('a')).toBe('sky');
+    expect(hashTable.get('d')).toBe('ocean');
+    expect(hashTable.get('x')).not.toBeDefined();
+
+    hashTable.delete('a');
+
+    expect(hashTable.delete('not-existing')).toBeNull();
+
+    expect(hashTable.get('a')).not.toBeDefined();
+    expect(hashTable.get('d')).toBe('ocean');
+
+    hashTable.set('d', 'ocean-new');
+    expect(hashTable.get('d')).toBe('ocean-new');
+  });
+
+  it('should be possible to add objects to hash table', () => {
+    const hashTable = new HashTable();
+
+    hashTable.set('objectKey', { prop1: 'a', prop2: 'b' });
+
+    const object = hashTable.get('objectKey');
+    expect(object).toBeDefined();
+    expect(object.prop1).toBe('a');
+    expect(object.prop2).toBe('b');
+  });
+
+  it('should track actual keys', () => {
+    const hashTable = new HashTable(3);
+
+    hashTable.set('a', 'sky-old');
+    hashTable.set('a', 'sky');
+    hashTable.set('b', 'sea');
+    hashTable.set('c', 'earth');
+    hashTable.set('d', 'ocean');
+
+    expect(hashTable.getKeys()).toEqual(['a', 'b', 'c', 'd']);
+    expect(hashTable.has('a')).toBe(true);
+    expect(hashTable.has('x')).toBe(false);
+
+    hashTable.delete('a');
+
+    expect(hashTable.has('a')).toBe(false);
+    expect(hashTable.has('b')).toBe(true);
+    expect(hashTable.has('x')).toBe(false);
+  });
+
+  it('should get all the values', () => {
+    const hashTable = new HashTable(3);
+
+    hashTable.set('a', 'alpha');
+    hashTable.set('b', 'beta');
+    hashTable.set('c', 'gamma');
+
+    expect(hashTable.getValues()).toEqual(['gamma', 'alpha', 'beta']);
+  });
+
+  it('should get all the values from empty hash table', () => {
+    const hashTable = new HashTable();
+    expect(hashTable.getValues()).toEqual([]);
+  });
+
+  it('should get all the values in case of hash collision', () => {
+    const hashTable = new HashTable(3);
+
+    // Keys `ab` and `ba` in current implementation should result in one hash (one bucket).
+    // We need to make sure that several items from one bucket will be serialized.
+    hashTable.set('ab', 'one');
+    hashTable.set('ba', 'two');
+
+    hashTable.set('ac', 'three');
+
+    expect(hashTable.getValues()).toEqual(['one', 'two', 'three']);
+  });
+});

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

@@ -0,0 +1,70 @@
+export class HashTable {
+  buckets: Array<Array<any>>;
+  keys: {};
+
+  constructor(bucketsLength: number = 32) {
+    this.buckets = new Array<Array<any>>(bucketsLength);
+    this.keys = {};
+  }
+
+  hash(key: string): number {
+    return key
+      .split("")
+      .map((k) => k.charCodeAt(0))
+      .reduce((a, b) => a + b, 0) % this.buckets.length;
+  }
+
+  set(key: string, value: any) {
+    const hash = this.hash(key);
+    if (this.has(key)) {
+      for (var entry of this.buckets[hash]) {
+        if (entry.key === key) {
+          entry.value = value;
+        }
+      }
+    } else {
+      if (!this.buckets[hash]) {
+        this.buckets[hash] = [];
+      }
+      this.buckets[hash].push({ key, value });
+    }
+    this.keys[key] = hash;
+  }
+
+  has(key: string): boolean {
+    return Object.hasOwnProperty.call(this.keys, key);
+  }
+
+  get(key: string): any {
+    const hash = this.hash(key);
+    const bucket = this.buckets[hash];
+    return bucket?.find((v) => v.key === key)?.value;
+  }
+
+  delete(key: string) {
+    if (!this.has(key)) {
+      return null;
+    }
+
+    const hash = this.hash(key);
+    delete this.keys[key];
+    if (!this.buckets[hash]) {
+      return null;
+    }
+
+    this.buckets[this.hash(key)] = [
+      ...this.buckets[this.hash(key)].filter((pair) => pair.key != key),
+    ];
+  }
+
+  getKeys(): string[] {
+    return Object.keys(this.keys);
+  }
+
+  getValues(): any[] {
+    return this.buckets.reduce((values, bucket) => {
+      const bucketValues = bucket.map((pair) => pair.value);
+      return values.concat(bucketValues);
+    }, []);
+  }
+}

src/data-structures/linked-list/__test__/linkedList.test.ts

@@ -147,7 +147,7 @@ describe('LinkedList', () => {
       .prepend(nodeValue2);
 
     const nodeStringifier = (value) => `${value.key}:${value.value}`;
-debugger;
+
     expect(linkedList.toString(nodeStringifier)).toBe('key2:2,key1:1');
   });