rehash implemented

Author: amejiarosario

README.md

@@ -20,3 +20,21 @@ Combine all words
 ```sh
 cat src/data-structures/hash-maps/data/* > src/data-structures/hash-maps/data/00-combined.txt
 ```
+## ESLint
+
+```js
+somthing(t) => 1 // eslint-disable-line no-unused-vars
+
+// eslint-disable-next-line no-use-before-define
+const thing = new Thing();
+
+/*eslint-disable */
+//suppress all warnings between comments
+alert('foo');
+/*eslint-enable */
+
+
+/* eslint-disable no-alert, no-console */
+alert('foo');
+console.log('bar');
+/* e

src/data-structures/hash-maps/hashmap.js

@@ -1,4 +1,5 @@
 const LinkedList = require('../linked-lists/linked-list');
+const { nextPrime } = require('./primes');
 
 class HashMap {
   /**
@@ -8,12 +9,23 @@ class HashMap {
    *  rehash when the load factor threshold is met
    */
   constructor(initialCapacity = 19, loadFactor = 0.75) {
-    this.buckets = new Array(initialCapacity);
+    this.initialCapacity = initialCapacity;
     this.loadFactor = loadFactor;
-    this.size = 0;
-    this.collisions = 0;
-    this.keysTrackerArray = [];
-    this.keysTrackerIndex = 0;
+    this.reset();
+  }
+
+  reset(
+    buckets = new Array(this.initialCapacity),
+    size = 0,
+    collisions = 0,
+    keysTrackerArray = [],
+    keysTrackerIndex = 0,
+  ) {
+    this.buckets = buckets;
+    this.size = size;
+    this.collisions = collisions;
+    this.keysTrackerArray = keysTrackerArray;
+    this.keysTrackerIndex = keysTrackerIndex;
   }
 
   set(key, value) {
@@ -39,11 +51,20 @@ class HashMap {
     return this.removeBucket(index, key);
   }
 
+  /**
+   * Uses FVN-1a hashing algorithm for 32 bits
+   * @see https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+   * @param {any} key
+   * @return {integer} bucket index
+   */
   hashFunction(key) {
-    const hashCode = Array.from(key.toString()).reduce((hash, char) => {
-      return char.codePointAt() + (hash * 41);
-    }, 0);
-    return hashCode % this.buckets.length;
+    const str = key.toString();
+    let hash = 2166136261;
+    for (let i = 0; i < str.length; i += 1) {
+      hash ^= str.codePointAt(i); // eslint-disable-line no-bitwise
+      hash *= 16777619;
+    }
+    return (hash >>> 0) % this.buckets.length; // eslint-disable-line no-bitwise
   }
 
   setBucket(index, key, value) {
@@ -71,6 +92,10 @@ class HashMap {
       if (bucket.size > 1) {
         this.collisions += 1;
       }
+
+      if (this.isBeyondloadFactor()) {
+        this.rehash();
+      }
     }
   }
 
@@ -105,12 +130,33 @@ class HashMap {
     return this.size / this.buckets.length;
   }
 
+  isBeyondloadFactor() {
+    return this.getLoadFactor() > this.loadFactor;
+  }
+
   /**
    * @returns keys without holes (empty spaces of deleted keys)
    */
   keys() {
     return Object.values(this.keysTrackerArray);
   }
+
+  rehash(newBucketSize = Math.max(this.size, this.buckets.length) * 2) {
+    const newCapacity = nextPrime(newBucketSize);
+    const newMap = new HashMap(newCapacity);
+    this.keys().forEach((key) => {
+      newMap.set(key, this.get(key));
+    });
+    const newArrayKeys = newMap.keys();
+
+    this.reset(
+      newMap.buckets,
+      newMap.size,
+      newMap.collisions,
+      newArrayKeys,
+      newArrayKeys.length,
+    );
+  }
 }
 
 module.exports = HashMap;

src/data-structures/hash-maps/hashmap.spec.js

@@ -41,7 +41,7 @@ describe('HashMap Tests', () => {
       expect(hashMap.getLoadFactor()).toBe(0);
       expect(hashMap.size).toBe(0);
       hashMap.set('test', 'one');
-      expect(hashMap.getLoadFactor()).toBe(1 / 16);
+      expect(hashMap.getLoadFactor()).toBeGreaterThan(0);
       expect(hashMap.size).toBe(1);
     });
 
@@ -68,7 +68,7 @@ describe('HashMap Tests', () => {
     let hashMap;
 
     beforeEach(() => {
-      hashMap = new HashMap(1, 0);
+      hashMap = new HashMap(1, Number.MAX_SAFE_INTEGER);
 
       hashMap.set('Pineapple', 'Pen Pineapple Apple Pen');
       hashMap.set('Despacito', 'Luis Fonsi');
@@ -143,11 +143,11 @@ describe('HashMap Tests', () => {
     });
   });
 
-  xdescribe('#rehash', () => {
+  describe('#rehash', () => {
     let hashMap;
 
     beforeEach(() => {
-      hashMap = new HashMap();
+      hashMap = new HashMap(1, 11);
 
       hashMap.set('Pineapple', 'Pen Pineapple Apple Pen');
       hashMap.set('Despacito', 'Luis Fonsi');
@@ -162,20 +162,43 @@ describe('HashMap Tests', () => {
       hashMap.set('The Spectre', 'Alan Walker');
     });
 
-    it('should rehash after 12 items by default', () => {
-      expect(hashMap.getLoadFactor()).toBe(11 / 16);
-      expect(hashMap.buckets.length).toBe(16);
+    it('should rehash', () => {
+      expect(hashMap.collisions).toBe(10);
+      expect(hashMap.getLoadFactor()).toBe(11);
+      expect(hashMap.buckets.length).toBe(1);
+
+      expect(hashMap.keysTrackerIndex).toBe(11);
+      hashMap.delete('All About That Bass');
+      hashMap.set('All About That Bass', 'Meghan Trainor');
+      expect(hashMap.keysTrackerIndex).toBe(12);
+      // should hava a hole
+      expect(hashMap.keysTrackerArray).toEqual(['Pineapple', 'Despacito', 'Bailando', 'Dura', 'Lean On', 'Hello',
+        undefined,
+        'Wake Me Up', 'Brother', 'Faded', 'The Spectre', 'All About That Bass']);
+
+      hashMap.loadFactor = 0.75;
       hashMap.set('Alone', 'Alan Walker');
-      expect(hashMap.getLoadFactor()).toBe(0.75);
 
-      hashMap.set('Levels', 'Avicii');
+      // rehash
+      expect(hashMap.keysTrackerIndex).toBe(12);
+      expect(hashMap.collisions).toBeLessThan(10);
+      expect(hashMap.buckets.length).toBe(29); // <- next prime
+      expect(hashMap.getLoadFactor()).toBe(12 / 29);
 
-      expect(hashMap.getLoadFactor()).toBe(13 / 32);
-      expect(hashMap.buckets.length).toBe(32);
+      hashMap.set('Rolling in the Deep', 'Adele');
 
       expect(hashMap.get('Dura')).toBe('Daddy Yankee');
       expect(hashMap.get('Bailando')).toBe('Enrique Iglesias');
-      expect(hashMap.get('Levels')).toBe('Avicii');
+      expect(hashMap.get('Alone')).toBe('Alan Walker');
+
+      expect(hashMap.keys().length).toBe(13);
+      expect(hashMap.size).toBe(13);
+      expect(hashMap.keysTrackerIndex).toBe(13);
+      // after the rehash the hole should have been removed
+      expect(hashMap.keysTrackerArray).toEqual(["Pineapple", "Despacito",
+        "Bailando", "Dura", "Lean On", "Hello", "Wake Me Up", "Brother",
+        "Faded", "The Spectre", "All About That Bass", "Alone",
+        "Rolling in the Deep"]);
     });
   });
 });

src/data-structures/hash-maps/primes.js

@@ -0,0 +1,47 @@
+/**
+ * Odd number checker
+ * Runtime: O(1)
+ * @param {integer} number
+ * @returns {boolean} true if is odd, otherwise false.
+ */
+function isOdd(number) {
+  return number % 2 !== 0;
+}
+
+/**
+ * Prime number tester
+ * Runtime: O(n ^ 0.5)
+ * @param {integer} number
+ * @returns {boolean} true if number is prime, otherwise false.
+ */
+function isPrime(number) {
+  if (number < 2) { return false; }
+  const max = Math.sqrt(number);
+  for (let divisor = 2; divisor <= max; divisor++) {
+    if (number % divisor === 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Find the next prime of a given number
+ * Runtime: ? // the gap between prime numbers is not deterministic.
+ * @param {integer} number
+ */
+function nextPrime(number) {
+  if (number < 2) { return 2; }
+  let possiblePrime = isOdd(number) ? number + 2 : number + 1;
+
+  while (!isPrime(possiblePrime)) {
+    possiblePrime += 2;
+  }
+  return possiblePrime;
+}
+
+module.exports = {
+  nextPrime,
+  isPrime,
+  isOdd,
+};

src/data-structures/hash-maps/primes.spec.js

@@ -0,0 +1,53 @@
+const { nextPrime, isPrime, isOdd } = require('./primes');
+
+describe('Prime Util Tests', () => {
+  describe('#isPrime', () => {
+    test('2 is prime', () => {
+      expect(isPrime(2)).toBe(true);
+    });
+
+    test('1 is not prime', () => {
+      expect(isPrime(1)).toBe(false);
+    });
+
+    test('large prime number', () => {
+      expect(isPrime(914021)).toBe(true);
+    });
+
+    test('non prime number', () => {
+      expect(isPrime(99)).toBe(false);
+    });
+  });
+
+  describe('#isOdd', () => {
+    it('odd number', () => {
+      expect(isOdd(1)).toBe(true);
+    });
+
+    it('even number', () => {
+      expect(isOdd(10)).toBe(false);
+    });
+
+    it('zero is an even number', () => {
+      expect(isOdd(0)).toBe(false);
+    });
+  });
+
+  describe('#nextPrime', () => {
+    it('should find the next prime of 19', () => {
+      expect(nextPrime(38)).toBe(41);
+    });
+
+    it('should find the next prime of 11558', () => {
+      expect(nextPrime(11558)).toBe(11579);
+    });
+
+    it('should find the next prime of large number', () => {
+      expect(nextPrime(11579 * 2)).toBe(23159);
+    });
+
+    it('should find of negative number', () => {
+      expect(nextPrime(-1)).toBe(2);
+    });
+  });
+});

src/data-structures/linked-lists/linked-list.js

@@ -12,6 +12,13 @@ class LinkedList {
     this.size = 0; // total number of elements in the list
   }
 
+  /**
+   * Alias for size
+   */
+  get length() {
+    return this.size;
+  }
+
   /**
    * Adds element to the begining of the list. Similar to Array.unshift
    * Runtime: O(1)