HashMap Implementation from Scratch in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this HashMap size check?

Consider this simple HashMap class with put and size methods. What will be printed after the operations?

DSA Javascript

class HashMap {
  constructor() {
    this.map = {};
  }
  put(key, value) {
    this.map[key] = value;
  }
  size() {
    return Object.keys(this.map).length;
  }
}
const map = new HashMap();
map.put('a', 1);
map.put('b', 2);
map.put('a', 3);
console.log(map.size());

A 1

B 2

C 0

D 3

💡 Hint

Think about what happens when you add a key that already exists.

The HashMap stores keys uniquely. Adding 'a' twice overwrites the first value, so only two keys exist: 'a' and 'b'.

❓ Predict Output

intermediate

What is the output after these put and get operations?

Given this HashMap implementation, what will be the output of the get calls?

DSA Javascript

class HashMap {
  constructor() {
    this.map = {};
  }
  put(key, value) {
    this.map[key] = value;
  }
  get(key) {
    return this.map[key] === undefined ? null : this.map[key];
  }
}
const map = new HashMap();
map.put('x', 10);
map.put('y', 20);
console.log(map.get('x'));
console.log(map.get('z'));

A 10\nnull

B 10\nundefined

C undefined\nnull

D 20\nnull

💡 Hint

Check how get handles keys not present in the map.

The get method returns the value if present, else null. 'x' exists with 10, 'z' does not exist, so null is returned.

🔧 Debug

advanced

Why does this HashMap implementation fail to store multiple keys?

This HashMap uses an array of buckets but fails to store multiple keys correctly. Identify the bug.

DSA Javascript

class HashMap {
  constructor(size = 5) {
    this.buckets = new Array(size).fill([]);
  }
  hash(key) {
    let hash = 0;
    for (let char of key) {
      hash += char.charCodeAt(0);
    }
    return hash % this.buckets.length;
  }
  put(key, value) {
    const index = this.hash(key);
    this.buckets[index].push([key, value]);
  }
  get(key) {
    const index = this.hash(key);
    for (let [k, v] of this.buckets[index]) {
      if (k === key) return v;
    }
    return null;
  }
}
const map = new HashMap();
map.put('a', 1);
map.put('b', 2);
console.log(map.get('a'));
console.log(map.get('b'));

A The get method always returns null because it never finds the key.

B The hash function is incorrect and returns the same index for all keys.

C The put method does not add key-value pairs to the buckets array.

D All keys share the same bucket array due to fill([]), causing overwrites and unexpected behavior.

💡 Hint

Check how the buckets array is initialized.

Using fill([]) assigns the same array reference to all buckets, so pushing to one bucket affects all buckets, causing data corruption.

❓ Predict Output

advanced

What is the output after removing a key from this HashMap?

This HashMap supports remove operation. What will be printed after these operations?

DSA Javascript

class HashMap {
  constructor() {
    this.map = {};
  }
  put(key, value) {
    this.map[key] = value;
  }
  remove(key) {
    if (this.map.hasOwnProperty(key)) {
      delete this.map[key];
      return true;
    }
    return false;
  }
  size() {
    return Object.keys(this.map).length;
  }
}
const map = new HashMap();
map.put('one', 1);
map.put('two', 2);
map.remove('one');
console.log(map.size());

A 0

B 2

C 1

D undefined

💡 Hint

Removing a key reduces the size by one if the key exists.

After removing 'one', only 'two' remains, so size is 1.

🧠 Conceptual

expert

Which property is essential for a good hash function in a HashMap?

To ensure efficient storage and retrieval in a HashMap, what property must the hash function have?

A It should distribute keys uniformly across buckets to minimize collisions.

B It should produce the same hash for different keys to save space.

C It should always return zero to simplify indexing.

D It should convert keys to strings regardless of type.

💡 Hint

Think about how collisions affect performance.

A good hash function distributes keys evenly to reduce collisions and maintain fast access times.

Practice

1. What is the main purpose of a HashMap in data structures?

easy

A. To store data in a sorted order

B. To store data as a sequence of elements

C. To store data in a last-in-first-out order

D. To store key-value pairs for fast data retrieval

Solution

1. Step 1: Understand what a HashMap stores

   A HashMap stores data as key-value pairs, allowing quick access to values using keys.

2. Step 2: Compare with other data structures

   Unlike lists or stacks, HashMaps focus on fast lookup, not order or sequence.

3. Final Answer:

   To store key-value pairs for fast data retrieval -> Option D

4. Quick Check:

   HashMap = key-value fast access [OK]

Hint: HashMaps store pairs for quick lookup by key [OK]

Common Mistakes:

• Confusing HashMap with list or stack
• Thinking HashMap stores data in order
• Assuming HashMap stores only values without keys

2. Which of the following is the correct way to define a simple HashMap class constructor in JavaScript?

easy

A. class HashMap { constructor() { this.map = {}; } }

B. class HashMap { constructor() { map = []; } }

C. function HashMap() { this.map = new Map(); }

D. class HashMap { constructor() { this.map = null; } }

Solution

1. Step 1: Check class syntax and property initialization

   class HashMap { constructor() { this.map = {}; } } correctly defines a class with a constructor initializing an object property this.map.

2. Step 2: Identify errors in other options

   class HashMap { constructor() { map = []; } } misses this., so map is not a property. function HashMap() { this.map = new Map(); } uses function syntax, not class. class HashMap { constructor() { this.map = null; } } initializes this.map to null, which is not useful for storing pairs.

3. Final Answer:

   class HashMap { constructor() { this.map = {}; } } -> Option A

4. Quick Check:

   Proper class constructor uses this.property = value [OK]

Hint: Use this.property inside constructor for class fields [OK]

Common Mistakes:

• Forgetting 'this.' before property name
• Mixing function and class syntax
• Initializing property to null instead of object

3. Consider this simple HashMap implementation snippet:

class HashMap {
  constructor() {
    this.map = {};
  }
  set(key, value) {
    this.map[key] = value;
  }
  get(key) {
    return this.map[key] || null;
  }
}

const h = new HashMap();
h.set('a', 1);
h.set('b', 2);
h.set('a', 3);
console.log(h.get('a'));

What will be printed?

medium

A. 3

B. 2

C. 1

D. null

Solution

1. Step 1: Trace the set operations

   First, key 'a' is set to 1, then 'b' to 2, then 'a' is updated to 3, overwriting previous value.

2. Step 2: Check the get operation

   Calling get('a') returns the current value for 'a', which is 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Last set value for 'a' = 3 [OK]

Hint: Last set value for a key overwrites previous [OK]

Common Mistakes:

• Assuming first set value remains
• Confusing keys and values
• Expecting null if key was set before

4. The following HashMap method is intended to remove a key-value pair but has a bug:

remove(key) {
  delete this.map.key;
}

What is the correct fix?

medium

A. Change to delete this.map->key;

B. Change to this.map.delete(key);

C. Change to delete this.map[key];

D. Change to this.map.remove(key);

Solution

1. Step 1: Understand property access in JavaScript objects

   Using dot notation with this.map.key looks for property literally named 'key', not the variable key.

2. Step 2: Use bracket notation for dynamic keys

   Bracket notation this.map[key] accesses the property named by the variable key. So delete this.map[key]; correctly deletes the key-value pair.

3. Final Answer:

   Change to delete this.map[key]; -> Option C

4. Quick Check:

   Use brackets for variable keys [OK]

Hint: Use brackets [] to delete dynamic keys [OK]

Common Mistakes:

• Using dot notation with variable keys
• Using non-existent methods like remove()
• Using wrong delete syntax

5. You want to implement a keys() method in your HashMap class that returns all keys stored. Which of these implementations correctly returns an array of keys?

hard

A. keys() { return Object.values(this.map); }

B. keys() { return Object.keys(this.map); }

C. keys() { return this.map.keys(); }

D. keys() { return this.map.getKeys(); }

Solution

1. Step 1: Identify how to get keys from a plain object

   JavaScript's Object.keys() returns an array of keys from an object.

2. Step 2: Check other options for correctness

   keys() { return this.map.keys(); } assumes this.map is a Map object, but here it's a plain object, so this.map.keys() is undefined. keys() { return Object.values(this.map); } returns values, not keys. keys() { return this.map.getKeys(); } uses a non-existent method.

3. Final Answer:

   keys() { return Object.keys(this.map); } -> Option B

4. Quick Check:

   Object.keys() returns keys array [OK]

Hint: Use Object.keys() to get keys from plain objects [OK]

Common Mistakes:

• Using Map methods on plain objects
• Returning values instead of keys
• Calling non-existent methods