hash maps

Author: amejiarosario

lib/data-structures/hash-maps/hash-map-1.js

@@ -1,43 +1,34 @@
 /**
- * Hash Map data structure implementation
+ * Naïve HashMap implementation
  */
 class HashMap {
 
   /**
    * Initialize array that holds the values. Default is size 1,000
-   * @param {number} size
+   * @param {number} initialCapacity
    */
-  constructor(size = 2) {
-    this.array = new Array(size);
+  constructor(initialCapacity = 2) {
+    this.buckets = new Array(initialCapacity);
   }
 
   /**
-   * insert a key/value pair into the hash map
+   * Insert a key/value pair into the hash map
+   * It doesn't handle collisions
    * @param {any} key
    * @param {any} value
    */
   set(key, value) {
     const index = this.getIndex(key);
-    if(this.array[index]) {
-      this.array[index].push({key, value});
-    } else {
-      this.array[index] = [{key, value}];
-    }
-    return this;
+    this.buckets[index] = value;
   }
 
   /**
    * Gets the value out of the hash map
    * @param {any} key
    */
   get(key) {
-    const hashIndex = this.getIndex(key);
-    for (let index = 0; index < this.array[hashIndex].length; index++) {
-      const entry = this.array[hashIndex][index];
-      if(entry.key === key) {
-        return entry.value
-      }
-    }
+    const index = this.getIndex(key);
+    return this.buckets[index];
   }
 
   /**
@@ -54,21 +45,27 @@ class HashMap {
    */
   getIndex(key) {
     const indexHash = this.hash(key);
-    const index = indexHash % this.array.length;
+    const index = indexHash % this.buckets.length;
     return index;
   }
 }
 
+// Usage:
 const assert = require('assert');
 const hashMap = new HashMap();
 
 hashMap.set('cat', 2);
 hashMap.set('rat', 7);
 hashMap.set('dog', 1);
-hashMap.set('art', 1);
+hashMap.set('art', 8);
 
-console.log(hashMap.array);
+console.log(hashMap.buckets);
+/*
+  bucket #0: <1 empty item>,
+  bucket #1: 8
+*/
 
-assert.equal(hashMap.get('cat'), 2);
-assert.equal(hashMap.get('rat'), 7);
-assert.equal(hashMap.get('dog'), 1);
+assert.equal(hashMap.get('art'), 8); // this one is ok
+assert.equal(hashMap.get('cat'), 8); // got overwritten by art 😱
+assert.equal(hashMap.get('rat'), 8); // got overwritten by art 😱
+assert.equal(hashMap.get('dog'), 8); // got overwritten by art 😱

lib/data-structures/hash-maps/hash-map-2.js

@@ -5,10 +5,11 @@ class HashMap {
 
   /**
    * Initialize array that holds the values. Default is size 1,000
-   * @param {number} size
+   * @param {number} initialCapacity
    */
-  constructor(size = 4) {
-    this.array = new Array(size);
+  constructor(initialCapacity = 2) {
+    this.buckets = new Array(initialCapacity);
+    this.collisions = 0;
   }
 
   /**
@@ -17,11 +18,12 @@ class HashMap {
    * @param {any} value
    */
   set(key, value) {
-    const index = this.getIndex(key);
-    if(this.array[index]) {
-      this.array[index].push({key, value});
+    const bucketIndex = this.getIndex(key);
+    if(this.buckets[bucketIndex]) {
+      this.buckets[bucketIndex].push({key, value});
+      if(this.buckets[bucketIndex].length > 1) { this.collisions++; }
     } else {
-      this.array[index] = [{key, value}];
+      this.buckets[bucketIndex] = [{key, value}];
     }
     return this;
   }
@@ -31,9 +33,9 @@ class HashMap {
    * @param {any} key
    */
   get(key) {
-    const hashIndex = this.getIndex(key);
-    for (let index = 0; index < this.array[hashIndex].length; index++) {
-      const entry = this.array[hashIndex][index];
+    const bucketIndex = this.getIndex(key);
+    for (let arrayIndex = 0; arrayIndex < this.buckets[bucketIndex].length; arrayIndex++) {
+      const entry = this.buckets[bucketIndex][arrayIndex];
       if(entry.key === key) {
         return entry.value
       }
@@ -47,11 +49,11 @@ class HashMap {
    */
   hash(key) {
     let hashValue = 0;
-    const stringKey = key.toString();
+    const stringTypeKey = `${key}${typeof key}`;
 
-    for (let index = 0; index < stringKey.length; index++) {
-      const charCode = stringKey.charCodeAt(index);
-      hashValue += charCode;
+    for (let index = 0; index < stringTypeKey.length; index++) {
+      const charCode = stringTypeKey.charCodeAt(index);
+      hashValue += charCode << (index * 8);
     }
 
     return hashValue;
@@ -63,21 +65,64 @@ class HashMap {
    */
   getIndex(key) {
     const indexHash = this.hash(key);
-    const index = indexHash % this.array.length;
+    const index = indexHash % this.buckets.length;
     return index;
   }
 }
 
+// Usage:
 const assert = require('assert');
 const hashMap = new HashMap();
 
 hashMap.set('cat', 2);
 hashMap.set('rat', 7);
 hashMap.set('dog', 1);
-hashMap.set('art', 0); // <-- collision with rat
+hashMap.set('art', 8);
 
-console.log(hashMap.array);
+console.log('collisions: ', hashMap.collisions);
+console.log('hashMap.buckets\n', hashMap.buckets);
+/*
+  bucket #0: [ { key: 'cat', value: 2 }, { key: 'dog', value: 1 } ]
+  bucket #1: [ { key: 'rat', value: 7 }, { key: 'dog', value: 1 } ]
+*/
 
-assert.equal(hashMap.get('cat'), 2);
-assert.equal(hashMap.get('rat'), 7);
-assert.equal(hashMap.get('dog'), 1);
+assert.equal(hashMap.get('art'), 8); // this one is ok
+assert.equal(hashMap.get('cat'), 2); // Good. Didn't got overwritten by art
+assert.equal(hashMap.get('rat'), 7); // Good. Didn't got overwritten by art
+assert.equal(hashMap.get('dog'), 1); // Good. Didn't got overwritten by art
+
+
+//
+
+
+const hashMapSize10 = new HashMap(10);
+
+hashMapSize10.set('cat', 2);
+hashMapSize10.set('rat', 7);
+hashMapSize10.set('dog', 1);
+hashMapSize10.set('art', 8);
+
+console.log('collisions: ', hashMapSize10.collisions);
+console.log('hashMapSize10\n', hashMapSize10.buckets);
+/*
+  bucket#0: [ { key: 'cat', value: 2 }, { key: 'art', value: 8 } ],
+  <4 empty items>,
+  bucket#5: [ { key: 'rat', value: 7 } ],
+  <1 empty item>,
+  bucket#7: [ { key: 'dog', value: 1 } ],
+  <2 empty items> ]
+*/
+
+
+//
+
+
+const hashMapSize100 = new HashMap(100);
+
+hashMapSize100.set('cat', 2);
+hashMapSize100.set('rat', 7);
+hashMapSize100.set('dog', 1);
+hashMapSize100.set('art', 8);
+
+console.log('collisions: ', hashMapSize100.collisions);
+console.log('hashMapSize100\n', hashMapSize100.buckets);