Skip to content

Commit 4c8cde1

Browse files
amejiarosarioamejiarosario
committedOct 7, 2018
rename hash-map files
1 parent 822df38 commit 4c8cde1

File tree

7 files changed

+553
-5
lines changed

7 files changed

+553
-5
lines changed
 

‎benchmarks/hashmap.perf.js

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -113,7 +113,7 @@ function useBenchmark() {
113113
const HashMapSmallBucket = require('../src/data-structures/hash-maps/hash-map-2');
114114
const HashMap3 = require('../src/data-structures/hash-maps/hash-map-3');
115115
const HashMap4 = require('../src/data-structures/hash-maps/hash-map-4');
116-
const HashMap = require('../src/data-structures/hash-maps/hashmap');
116+
const HashMap = require('../src/data-structures/hash-maps/hash-map');
117117

118118
// // Map (built-in) x 2,257 ops/sec ±2.42% (75 runs sampled)
119119
// suite.add('Map (built-in)', function() {

‎package.json

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@
44
"description": "Algorithms in JS",
55
"main": "./src/data-structures/graphs/graph.js",
66
"dependencies": {
7-
"lodash": "4.17.10",
7+
"lodash": "4.17.10"
88
},
99
"devDependencies": {
1010
"benchmark": "2.1.4",

‎src/data-structures/graphs/graph.js

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@
22
const Node = require('./node');
33
const Stack = require('../stacks/stack');
44
const Queue = require('../queues/queue');
5-
const HashMap = require('../maps/hash-maps/hashmap');
5+
const HashMap = require('../maps/hash-maps/hash-map');
66

77
/**
88
* Graph that uses an adjacent list

‎src/data-structures/maps/hash-maps/hash-map.js

Lines changed: 249 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,249 @@
1+
/* eslint-disable no-bitwise, no-iterator, no-restricted-syntax */
2+
const LinkedList = require('../../linked-lists/linked-list');
3+
const { nextPrime } = require('./primes');
4+
5+
/**
6+
* The Map object holds key-value pairs.
7+
* Any value (both objects and primitive values) may be used as either a key or a value.
8+
*
9+
* Features:
10+
* - HashMap offers avg. 0(1) lookup, insertion and deletion.
11+
* - Keys and values are ordered by their insertion order (like Java's LinkedHashMap)
12+
* - It contains only unique key.
13+
* - It may have one null key and multiple null values.
14+
*/
15+
class HashMap {
16+
/**
17+
* Initialize array that holds the values.
18+
* @param {number} initialCapacity initial size of the array (should be a prime)
19+
* @param {number} loadFactor if set, the Map will automatically
20+
* rehash when the load factor threshold is met
21+
*/
22+
constructor(initialCapacity = 19, loadFactor = 0.75) {
23+
this.initialCapacity = initialCapacity;
24+
this.loadFactor = loadFactor;
25+
this.reset();
26+
}
27+
28+
reset(
29+
buckets = new Array(this.initialCapacity),
30+
size = 0,
31+
collisions = 0,
32+
keysTrackerArray = [],
33+
keysTrackerIndex = 0,
34+
) {
35+
this.buckets = buckets;
36+
this.size = size;
37+
this.collisions = collisions;
38+
this.keysTrackerArray = keysTrackerArray;
39+
this.keysTrackerIndex = keysTrackerIndex;
40+
}
41+
42+
/**
43+
* Polynomial hash codes are used to hash String typed keys.
44+
* It uses FVN-1a hashing algorithm for 32 bits
45+
* @see https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
46+
* @param {any} key
47+
* @return {integer} bucket index
48+
*/
49+
hashFunction(key) {
50+
const str = String(key);
51+
let hash = 2166136261; // FNV_offset_basis (32 bit)
52+
for (let i = 0; i < str.length; i += 1) {
53+
hash ^= str.codePointAt(i); // XOR
54+
hash *= 16777619; // 32 bit FNV_prime
55+
}
56+
return (hash >>> 0) % this.buckets.length;
57+
}
58+
59+
/**
60+
* Find an entry inside a bucket.
61+
*
62+
* The bucket is an array of LinkedList.
63+
* Entries are each of the nodes in the linked list.
64+
*
65+
* Avg. Runtime: O(1)
66+
* If there are many collisions it could be O(n).
67+
*
68+
* @param {any} key
69+
* @param {function} callback (optional) operation to
70+
* perform once the entry has been found
71+
* @returns {object} object containing the bucket and entry (LinkedList's node's value)
72+
*/
73+
getEntry(key, callback = () => {}) {
74+
const index = this.hashFunction(key);
75+
this.buckets[index] = this.buckets[index] || new LinkedList();
76+
const bucket = this.buckets[index];
77+
78+
const entry = bucket.find(({ value: node }) => {
79+
if (key === node.key) {
80+
callback(node);
81+
return node;
82+
}
83+
return undefined;
84+
});
85+
return { bucket, entry };
86+
}
87+
88+
/**
89+
* Insert a key/value pair into the hash map.
90+
* If the key is already there replaces its content.
91+
* Avg. Runtime: O(1)
92+
* In the case a rehash is needed O(n).
93+
* @param {any} key
94+
* @param {any} value
95+
* @returns {HashMap} Return the Map object to allow chaining
96+
*/
97+
set(key, value) {
98+
const { entry: exists, bucket } = this.getEntry(key, (entry) => {
99+
entry.value = value; // update value if key already exists
100+
});
101+
102+
if (!exists) { // add key/value if it doesn't find the key
103+
bucket.push({ key, value, order: this.keysTrackerIndex });
104+
this.keysTrackerArray[this.keysTrackerIndex] = key;
105+
this.keysTrackerIndex += 1;
106+
this.size += 1;
107+
if (bucket.size > 1) { this.collisions += 1; }
108+
if (this.isBeyondloadFactor()) { this.rehash(); }
109+
}
110+
return this;
111+
}
112+
113+
/**
114+
* Gets the value out of the hash map
115+
* Avg. Runtime: O(1)
116+
* @param {any} key
117+
* @returns {any} value associated to the key, or undefined if there is none.
118+
*/
119+
get(key) {
120+
const { entry } = this.getEntry(key);
121+
return entry && entry.value;
122+
}
123+
124+
/**
125+
* Search for key and return true if it was found
126+
* Avg. Runtime: O(1)
127+
* @param {any} key
128+
* @returns {boolean} indicating whether an element
129+
* with the specified key exists or not.
130+
*/
131+
has(key) {
132+
const { entry } = this.getEntry(key);
133+
return entry !== undefined;
134+
}
135+
136+
/**
137+
* Removes the specified element from a Map object.
138+
* Avg. Runtime: O(1)
139+
* @param {*} key
140+
* @returns {boolean} true if an element in the Map object existed
141+
* and has been removed, or false if the element did not exist.
142+
*/
143+
delete(key) {
144+
const { bucket, entry } = this.getEntry(key);
145+
if (!entry) { return false; }
146+
147+
return !!bucket.remove((node) => {
148+
if (key === node.value.key) {
149+
delete this.keysTrackerArray[node.value.order]; // O(1) deletion
150+
this.size -= 1;
151+
return true;
152+
}
153+
return undefined;
154+
});
155+
}
156+
157+
/**
158+
* Load factor - measure how full the Map is.
159+
* It's ratio between items on the map and total size of buckets
160+
*/
161+
getLoadFactor() {
162+
return this.size / this.buckets.length;
163+
}
164+
165+
/**
166+
* Check if a rehash is due
167+
*/
168+
isBeyondloadFactor() {
169+
return this.getLoadFactor() > this.loadFactor;
170+
}
171+
172+
/**
173+
* Rehash means to create a new Map with a new (higher)
174+
* capacity with the purpose of outgrow collisions.
175+
* @param {integer} newBucketSize new bucket size by default
176+
* is the 2x the amount of data or bucket size.
177+
*/
178+
rehash(newBucketSize = Math.max(this.size, this.buckets.length) * 2) {
179+
const newCapacity = nextPrime(newBucketSize);
180+
const newMap = new HashMap(newCapacity);
181+
182+
for (const key of this.keys()) {
183+
newMap.set(key, this.get(key));
184+
}
185+
186+
const newArrayKeys = Array.from(newMap.keys());
187+
188+
this.reset(
189+
newMap.buckets,
190+
newMap.size,
191+
newMap.collisions,
192+
newArrayKeys,
193+
newArrayKeys.length,
194+
);
195+
}
196+
197+
/**
198+
* Keys for each element in the Map object in insertion order.
199+
* @returns {Iterator} keys without holes (empty spaces of deleted keys)
200+
*/
201+
* keys() {
202+
for (let index = 0; index < this.keysTrackerArray.length; index++) {
203+
const key = this.keysTrackerArray[index];
204+
if (key !== undefined) {
205+
yield key;
206+
}
207+
}
208+
}
209+
210+
/**
211+
* Values for each element in the Map object in insertion order.
212+
* @returns {Iterator} values without holes (empty spaces of deleted values)
213+
*/
214+
* values() {
215+
for (const key of this.keys()) {
216+
yield this.get(key);
217+
}
218+
}
219+
220+
/**
221+
* Contains the [key, value] pairs for each element in the Map object in insertion order.
222+
* @returns {Iterator}
223+
*/
224+
* entries() {
225+
for (const key of this.keys()) {
226+
yield [key, this.get(key)];
227+
}
228+
}
229+
230+
/**
231+
* the same function object as the initial value of the `entries` method.
232+
* Contains the [key, value] pairs for each element in the Map.
233+
*/
234+
* [Symbol.iterator]() {
235+
yield* this.entries();
236+
}
237+
238+
/**
239+
* @returns {integer} number of elements in the hashmap
240+
*/
241+
get length() {
242+
return this.size;
243+
}
244+
}
245+
246+
// Aliases
247+
HashMap.prototype.containsKey = HashMap.prototype.has;
248+
249+
module.exports = HashMap;

‎src/data-structures/maps/hash-maps/hash-map.spec.js

Lines changed: 299 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,299 @@
1+
const HashMap = require('./hash-map');
2+
// import HashMap from './hash-map';
3+
4+
5+
describe('HashMap Tests', () => {
6+
let hashMap;
7+
8+
beforeEach(() => {
9+
hashMap = new HashMap();
10+
});
11+
12+
describe('set and get basics', () => {
13+
it('should hold one null key', () => {
14+
hashMap.set(null, 1);
15+
hashMap.set(null, 2);
16+
expect(hashMap.get(null)).toBe(2);
17+
});
18+
19+
it('should hold multiple null values', () => {
20+
hashMap.set(1, null);
21+
hashMap.set(2, null);
22+
expect(hashMap.get(1)).toBe(null);
23+
expect(hashMap.get(2)).toBe(null);
24+
});
25+
});
26+
27+
describe('#keys', () => {
28+
it('should get keys', () => {
29+
hashMap.set(0, 'foo');
30+
hashMap.set(null, 'fox');
31+
hashMap.set('a', 'bar');
32+
hashMap.set({}, 'baz');
33+
34+
const mapIter = hashMap.keys();
35+
36+
expect(mapIter.next().value).toBe(0);
37+
expect(mapIter.next().value).toBe(null);
38+
expect(mapIter.next().value).toBe('a');
39+
expect(mapIter.next().value).toEqual({});
40+
});
41+
42+
it('should not have holes', () => {
43+
hashMap.set('0', 'foo');
44+
hashMap.set(1, 'bar');
45+
hashMap.set({}, 'baz');
46+
47+
hashMap.delete(1);
48+
49+
expect([...hashMap.keys()]).toEqual(['0', {}]);
50+
});
51+
});
52+
53+
describe('#values', () => {
54+
it('should get values', () => {
55+
hashMap.set('0', 'foo');
56+
hashMap.set(1, 'bar');
57+
hashMap.set({}, 'baz');
58+
59+
const mapIter = hashMap.values();
60+
61+
expect(mapIter.next().value).toBe('foo');
62+
expect(mapIter.next().value).toBe('bar');
63+
expect(mapIter.next().value).toBe('baz');
64+
});
65+
66+
it('should not have holes', () => {
67+
hashMap.set('0', 'foo');
68+
hashMap.set(1, 'bar');
69+
hashMap.set({}, 'baz');
70+
71+
hashMap.delete(1);
72+
73+
expect(Array.from(hashMap.values())).toEqual(['foo', 'baz']);
74+
});
75+
});
76+
77+
describe('#entries', () => {
78+
it('should get values', () => {
79+
hashMap.set('0', 'foo');
80+
hashMap.set(1, 'bar');
81+
hashMap.set({}, 'baz');
82+
83+
const mapIter = hashMap.entries();
84+
85+
expect(mapIter.next().value).toEqual(['0', 'foo']);
86+
expect(mapIter.next().value).toEqual([1, 'bar']);
87+
expect(mapIter.next().value).toEqual([{}, 'baz']);
88+
});
89+
90+
it('should not have holes', () => {
91+
hashMap.set('0', 'foo');
92+
hashMap.set(1, 'bar');
93+
hashMap.set({}, 'baz');
94+
95+
hashMap.delete(1);
96+
expect(hashMap.length).toBe(2);
97+
expect(hashMap.size).toBe(2);
98+
99+
expect(Array.from(hashMap.entries())).toEqual([
100+
['0', 'foo'],
101+
[{}, 'baz'],
102+
]);
103+
104+
expect(Array.from(hashMap)).toEqual([
105+
['0', 'foo'],
106+
[{}, 'baz'],
107+
]);
108+
});
109+
});
110+
111+
describe('without collisions', () => {
112+
it('set and get values', () => {
113+
hashMap.set('test', 'one');
114+
expect(hashMap.get('test')).toBe('one');
115+
});
116+
117+
it('should increase size', () => {
118+
expect(hashMap.size).toBe(0);
119+
hashMap.set('test', 'uno');
120+
expect(hashMap.size).toBe(1);
121+
});
122+
123+
it('has without value', () => {
124+
expect(hashMap.size).toBe(0);
125+
hashMap.set('uno');
126+
expect(hashMap.size).toBe(1);
127+
expect(hashMap.has('uno')).toBe(true);
128+
expect(hashMap.has('dos')).toBe(false);
129+
});
130+
131+
it('should overwrite values and keep same size', () => {
132+
hashMap.set('test', 'uno');
133+
expect(hashMap.get('test')).toBe('uno');
134+
hashMap.set('test', 'dos');
135+
expect(hashMap.get('test')).toBe('dos');
136+
expect(hashMap.size).toBe(1);
137+
});
138+
139+
it('should increase load factor and size', () => {
140+
expect(hashMap.getLoadFactor()).toBe(0);
141+
expect(hashMap.size).toBe(0);
142+
hashMap.set('test', 'one');
143+
expect(hashMap.getLoadFactor()).toBeGreaterThan(0);
144+
expect(hashMap.size).toBe(1);
145+
});
146+
147+
it('should return with has', () => {
148+
expect(hashMap.has('test')).toBe(false);
149+
hashMap.set('test', 'uno');
150+
expect(hashMap.has('test')).toBe(true);
151+
});
152+
153+
it('should delete', () => {
154+
hashMap.set('Despacito', 'Luis Fonsi');
155+
hashMap.set('Bailando', 'Enrique Iglesias');
156+
hashMap.set('Dura', 'Daddy Yankee');
157+
158+
expect(hashMap.size).toBe(3);
159+
expect(hashMap.delete('Bailando')).toBe(true);
160+
expect(hashMap.size).toBe(2);
161+
expect(hashMap.delete('Bailando')).toBe(false);
162+
expect(hashMap.get('Bailando')).toBe(undefined);
163+
});
164+
});
165+
166+
describe('with many values (and collisions)', () => {
167+
beforeEach(() => {
168+
hashMap = new HashMap(1, Number.MAX_SAFE_INTEGER);
169+
170+
hashMap.set('Pineapple', 'Pen Pineapple Apple Pen');
171+
hashMap.set('Despacito', 'Luis Fonsi');
172+
hashMap.set('Bailando', 'Enrique Iglesias');
173+
hashMap.set('Dura', 'Daddy Yankee');
174+
hashMap.set('Lean On', 'Major Lazer');
175+
hashMap.set('Hello', 'Adele');
176+
hashMap.set('All About That Bass', 'Meghan Trainor');
177+
hashMap.set('This Is What You Came For', 'Calvin Harris ');
178+
});
179+
180+
it('should count collisions', () => {
181+
expect(hashMap.collisions).toBe(7);
182+
});
183+
184+
it('gets values', () => {
185+
hashMap.set('test', 'one');
186+
expect(hashMap.get('test')).toBe('one');
187+
expect(hashMap.get('Dura')).toBe('Daddy Yankee');
188+
expect(hashMap.get('Bailando')).toBe('Enrique Iglesias');
189+
});
190+
191+
it('should increase load factor and size', () => {
192+
expect(hashMap.getLoadFactor()).toBe(8);
193+
expect(hashMap.size).toBe(8);
194+
hashMap.set('test', 'one');
195+
expect(hashMap.getLoadFactor()).toBe(9);
196+
expect(hashMap.size).toBe(9);
197+
});
198+
199+
it('should overwrite values and keep same size', () => {
200+
hashMap.set('test', 'uno');
201+
expect(hashMap.get('test')).toBe('uno');
202+
hashMap.set('test', 'dos');
203+
expect(hashMap.get('test')).toBe('dos');
204+
expect(hashMap.size).toBe(9);
205+
});
206+
207+
it('should return with has', () => {
208+
expect(hashMap.has('test')).toBe(false);
209+
hashMap.set('test', 'uno');
210+
expect(hashMap.has('test')).toBe(true);
211+
});
212+
213+
it('should update keys on deletes', () => {
214+
// expect(hashMap.size).toBe(8);
215+
// expect(hashMap.has('Hello')).toBe(true);
216+
expect(hashMap.delete('Hello')).toBe(true);
217+
// expect(hashMap.has('Hello')).toBe(false);
218+
// expect(hashMap.size).toBe(7);
219+
expect(hashMap.delete('Lean On')).toBe(true);
220+
// expect(hashMap.has('Lean On')).toBe(false);
221+
// expect(hashMap.size).toBe(6);
222+
expect(hashMap.delete('Pineapple')).toBe(true);
223+
// expect(hashMap.has('Pineapple')).toBe(false);
224+
// expect(hashMap.size).toBe(5);
225+
expect(hashMap.delete('All About That Bass')).toBe(true);
226+
expect(hashMap.has('All About That Bass')).toBe(false);
227+
// expect(hashMap.size).toBe(4);
228+
expect(hashMap.delete('This Is What You Came For')).toBe(true);
229+
expect(hashMap.has('This Is What You Came For')).toBe(false);
230+
expect(hashMap.size).toBe(3);
231+
232+
expect(Array.from(hashMap.keys())).toEqual(['Despacito', 'Bailando', 'Dura']);
233+
234+
expect(hashMap.delete('Bailando')).toBe(true);
235+
expect(hashMap.delete('Bailando')).toBe(false);
236+
expect(hashMap.get('Bailando')).toBe(undefined);
237+
238+
expect(hashMap.size).toBe(2);
239+
expect([...hashMap.keys()]).toEqual(['Despacito', 'Dura']);
240+
});
241+
});
242+
243+
describe('#rehash', () => {
244+
beforeEach(() => {
245+
hashMap = new HashMap(1, 11);
246+
247+
hashMap.set('Pineapple', 'Pen Pineapple Apple Pen');
248+
hashMap.set('Despacito', 'Luis Fonsi');
249+
hashMap.set('Bailando', 'Enrique Iglesias');
250+
hashMap.set('Dura', 'Daddy Yankee');
251+
hashMap.set('Lean On', 'Major Lazer');
252+
hashMap.set('Hello', 'Adele');
253+
hashMap.set('All About That Bass', 'Meghan Trainor');
254+
hashMap.set('Wake Me Up', 'Avicii');
255+
hashMap.set('Brother', 'Avicii');
256+
hashMap.set('Faded', 'Alan Walker');
257+
hashMap.set('The Spectre', 'Alan Walker');
258+
});
259+
260+
it('should rehash', () => {
261+
expect(hashMap.collisions).toBe(10);
262+
expect(hashMap.getLoadFactor()).toBe(11);
263+
expect(hashMap.buckets.length).toBe(1);
264+
265+
expect(hashMap.keysTrackerIndex).toBe(11);
266+
hashMap.delete('All About That Bass');
267+
hashMap.set('All About That Bass', 'Meghan Trainor');
268+
expect(hashMap.keysTrackerIndex).toBe(12);
269+
// should hava a hole
270+
expect(hashMap.keysTrackerArray).toEqual(['Pineapple', 'Despacito', 'Bailando', 'Dura', 'Lean On', 'Hello',
271+
undefined,
272+
'Wake Me Up', 'Brother', 'Faded', 'The Spectre', 'All About That Bass']);
273+
274+
hashMap.loadFactor = 0.75;
275+
hashMap.set('Alone', 'Alan Walker');
276+
277+
// rehash
278+
expect(hashMap.keysTrackerIndex).toBe(12);
279+
expect(hashMap.collisions).toBeLessThan(10);
280+
expect(hashMap.buckets.length).toBe(29); // <- next prime
281+
expect(hashMap.getLoadFactor()).toBe(12 / 29);
282+
283+
hashMap.set('Rolling in the Deep', 'Adele');
284+
285+
expect(hashMap.get('Dura')).toBe('Daddy Yankee');
286+
expect(hashMap.get('Bailando')).toBe('Enrique Iglesias');
287+
expect(hashMap.get('Alone')).toBe('Alan Walker');
288+
289+
expect(Array.from(hashMap.keys()).length).toBe(13);
290+
expect(hashMap.size).toBe(13);
291+
expect(hashMap.keysTrackerIndex).toBe(13);
292+
// after the rehash the hole should have been removed
293+
expect(hashMap.keysTrackerArray).toEqual(['Pineapple', 'Despacito',
294+
'Bailando', 'Dura', 'Lean On', 'Hello', 'Wake Me Up', 'Brother',
295+
'Faded', 'The Spectre', 'All About That Bass', 'Alone',
296+
'Rolling in the Deep']);
297+
});
298+
});
299+
});

‎src/data-structures/maps/map.spec.js

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
const HashMap = require('./hash-maps/hashmap');
1+
const HashMap = require('./hash-maps/hash-map');
22
const TreeMap = require('./tree-maps/tree-map');
33

44
const mapImplementations = [

‎src/data-structures/sets/hash-set.js

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
const HashMap = require('../maps/hash-maps/hashmap');
1+
const HashMap = require('../maps/hash-maps/hash-map');
22

33
/**
44
* Set implemented with our HashMap

0 commit comments

Comments
 (0)
Please sign in to comment.