Add new hash table methods.

Author: trekhleb

src/data-structures/hash-table/HashTable.js

@@ -1,14 +1,29 @@
 importLinkedListfrom'../linked-list/LinkedList';
 
+// Hash table size directly affects on the number of collisions.
+// The bigger the hash table size the less collisions you'll get.
+// For demonstrating purposes hash table size is small to show how collisions
+// are being handled.
 constdefaultHashTableSize=32;
 
 exportdefaultclassHashTable{
+/**
+ * @param{number} hashTableSize
+ */
 constructor(hashTableSize=defaultHashTableSize){
 // Create hash table of certain size and fill each bucket with empty linked list.
 this.buckets=Array(hashTableSize).fill(null).map(()=>newLinkedList());
+
+// Just to keep track of all actual keys in a fast way.
+this.keys={};
 }
 
-// Converts key string to hash number.
+/**
+ * Converts key string to hash number.
+ *
+ * @param{string} key
+ * @return{number}
+ */
 hash(key){
 consthash=Array.from(key).reduce(
 (hashAccumulator,keySymbol)=>(hashAccumulator+keySymbol.charCodeAt(0)),
@@ -19,8 +34,14 @@ export default class HashTable{
 returnhash%this.buckets.length;
 }
 
-insert(key,value){
-constbucketLinkedList=this.buckets[this.hash(key)];
+/**
+ * @param{string} key
+ * @param{*} value
+ */
+set(key,value){
+constkeyHash=this.hash(key);
+this.keys[key]=keyHash;
+constbucketLinkedList=this.buckets[keyHash];
 constnode=bucketLinkedList.find({callback: nodeValue=>nodeValue.key===key});
 
 if(!node){
@@ -32,8 +53,14 @@ export default class HashTable{
 }
 }
 
+/**
+ * @param{string} key
+ * @return{*}
+ */
 delete(key){
-constbucketLinkedList=this.buckets[this.hash(key)];
+constkeyHash=this.hash(key);
+deletethis.keys[key];
+constbucketLinkedList=this.buckets[keyHash];
 constnode=bucketLinkedList.find({callback: nodeValue=>nodeValue.key===key});
 
 if(node){
@@ -43,10 +70,29 @@ export default class HashTable{
 returnnull;
 }
 
+/**
+ * @param{string} key
+ * @return{*}
+ */
 get(key){
 constbucketLinkedList=this.buckets[this.hash(key)];
 constnode=bucketLinkedList.find({callback: nodeValue=>nodeValue.key===key});
 
 returnnode ? node.value.value : null;
 }
+
+/**
+ * @param{string} key
+ * @return{boolean}
+ */
+has(key){
+returnObject.hasOwnProperty.call(this.keys,key);
+}
+
+/**
+ * @return{string[]}
+ */
+getKeys(){
+returnObject.keys(this.keys);
+}
 }

src/data-structures/hash-table/__test__/HashTable.test.js

@@ -17,19 +17,23 @@ describe('HashTable', () =>{
 expect(hashTable.hash('abc')).toBe(6);
 });
 
-it('should insert, read and delete data with collisions',()=>{
+it('should set, read and delete data with collisions',()=>{
 consthashTable=newHashTable(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.insert('a','sky-old');
-hashTable.insert('a','sky');
-hashTable.insert('b','sea');
-hashTable.insert('c','earth');
-hashTable.insert('d','ocean');
+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')).toBeFalsy();
+expect(hashTable.has('b')).toBeTruthy();
+expect(hashTable.has('c')).toBeTruthy();
 
 conststringifier=value=>`${value.key}:${value.value}`;
 
@@ -47,18 +51,38 @@ describe('HashTable', () =>{
 expect(hashTable.get('a')).toBeNull();
 expect(hashTable.get('d')).toBe('ocean');
 
-hashTable.insert('d','ocean-new');
+hashTable.set('d','ocean-new');
 expect(hashTable.get('d')).toBe('ocean-new');
 });
 
 it('should be possible to add objects to hash table',()=>{
 consthashTable=newHashTable();
 
-hashTable.insert('objectKey',{prop1: 'a',prop2: 'b'});
+hashTable.set('objectKey',{prop1: 'a',prop2: 'b'});
 
 constobject=hashTable.get('objectKey');
 expect(object).toBeDefined();
 expect(object.prop1).toBe('a');
 expect(object.prop2).toBe('b');
 });
+
+it('should track actual keys',()=>{
+consthashTable=newHashTable(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')).toBeTruthy();
+expect(hashTable.has('x')).toBeFalsy();
+
+hashTable.delete('a');
+
+expect(hashTable.has('a')).toBeFalsy();
+expect(hashTable.has('b')).toBeTruthy();
+expect(hashTable.has('x')).toBeFalsy();
+});
 });