Hash Map vs Array vs Linked List for Lookup in DSA Javascript - Interactive Comparison Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create an empty hash map in JavaScript.

DSA Javascript

const map = [1];

Drag options to blanks, or click blank then click option'

Anew Map()

B{}

Cnull

D[]

Attempts:

3 left

💡 Hint

Common Mistakes

Using an empty array [] instead of an object.

Using null which is not a map.

In JavaScript, an empty hash map can be created using an empty object literal {}.

2fill in blank

medium

Complete the code to find the index of value 5 in an array.

DSA Javascript

const index = arr.[1](5);

Drag options to blanks, or click blank then click option'

AfindIndex

Bfind

Cincludes

DindexOf

Attempts:

3 left

💡 Hint

Common Mistakes

Using find which returns the element, not index.

Using includes which returns true/false.

The indexOf method returns the index of the first occurrence of a value in an array.

3fill in blank

hard

Fix the error in the linked list search function to return true if value is found.

DSA Javascript

function searchLinkedList(head, val) {
  let current = head;
  while (current !== null) {
    if (current.value === [1]) {
      return true;
    }
    current = current.next;
  }
  return false;
}

Drag options to blanks, or click blank then click option'

Avalue

Bval.value

Cval

Dcurrent.val

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing with value which is undefined.

Using val.value which is incorrect.

The function should compare current.value with the input val to check for equality.

4fill in blank

hard

Fill both blanks to create a hash map from an array of keys with initial value 0.

DSA Javascript

const keys = ['a', 'b', 'c'];
const map = {};
for (let i = 0; i [1] keys.length; i++) {
  map[keys[i]] = [2];
}

Drag options to blanks, or click blank then click option'

A<

B<=

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using <= in loop condition causing out of bounds.

Assigning 1 instead of 0 as initial value.

The loop should run while i < keys.length and assign 0 as the initial value for each key.

5fill in blank

hard

Fill all three blanks to filter an array for values greater than 10 and create a map with those values as keys and true as values.

DSA Javascript

const arr = [5, 12, 8, 20];
const filteredMap = {};
for (let i = 0; i [1] arr.length; i++) {
  if (arr[i] [2] 10) {
    filteredMap[arr[i]] = [3];
  }
}

Drag options to blanks, or click blank then click option'

A<

B>

Ctrue

Dfalse

Attempts:

3 left

💡 Hint

Common Mistakes

Using <= in loop causing errors.

Using < instead of > in condition.

Assigning false instead of true.

The loop runs while i < arr.length. The condition checks if arr[i] > 10. If true, it sets filteredMap[arr[i]] = true.

Practice

1. Which data structure provides the fastest average lookup time for finding an element by key?

easy

A. Hash Map

B. Array

C. Linked List

D. Stack

Solution

1. Step 1: Understand lookup times for each data structure

   Hash Maps use keys to directly access values, giving average O(1) time. Arrays require scanning or index access, O(n) or O(1) if index known. Linked Lists require scanning, O(n).

2. Step 2: Compare average lookup speeds

   Hash Map is fastest for key-based lookup because it uses hashing. Arrays and Linked Lists are slower for key lookup.

3. Final Answer:

   Hash Map -> Option A

4. Quick Check:

   Fastest lookup by key = Hash Map [OK]

Hint: Hash Map uses keys for O(1) lookup, arrays and lists do not [OK]

Common Mistakes:

• Thinking arrays are always fastest because of index access
• Confusing linked list traversal with direct access
• Assuming stack is a lookup structure

2. Which of the following is the correct way to check if a key exists in a JavaScript Map?

easy

A. map.includes(key)

B. key in map

C. map.contains(key)

D. map.has(key)

Solution

1. Step 1: Recall JavaScript Map methods

   JavaScript Map has a method called has() to check if a key exists.

2. Step 2: Evaluate each option

   map.has(key) uses map.has(key) which is correct. 'key in map' works for objects, not Map. 'contains' and 'includes' are not Map methods.

3. Final Answer:

   map.has(key) -> Option D

4. Quick Check:

   Check key in Map = map.has(key) [OK]

Hint: Use map.has(key) to check keys in JavaScript Map [OK]

Common Mistakes:

• Using 'in' operator on Map instead of Object
• Using non-existent methods like contains or includes on Map
• Confusing array methods with Map methods

3. What will be the output of the following code?

const arr = [10, 20, 30, 40];
const map = new Map();
map.set('a', 1);
map.set('b', 2);

console.log(arr.indexOf(30));
console.log(map.has('b'));
console.log(map.get('c'));

medium

A. 2 true null

B. -1 false undefined

C. 2 true undefined

D. 3 true undefined

Solution

1. Step 1: Analyze array indexOf(30)

   Array arr is [10,20,30,40]. indexOf(30) returns 2 because 30 is at index 2.

2. Step 2: Check map.has('b') and map.get('c')

   map.has('b') is true because 'b' exists. map.get('c') returns undefined because 'c' key does not exist.

3. Final Answer:

   2 true undefined -> Option C

4. Quick Check:

   indexOf(30)=2, has('b')=true, get('c')=undefined [OK]

Hint: indexOf returns index or -1; Map.get returns undefined if key missing [OK]

Common Mistakes:

• Assuming map.get returns null for missing keys
• Confusing array index with value
• Thinking map.has returns value instead of boolean

4. The following code tries to find if a value exists in a linked list. What is the bug?

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

function contains(head, target) {
  if (head === null) return false;
  while (head.next !== null) {
    if (head.value === target) return true;
    head = head.next;
  }
  return false;
}

medium

A. It misses checking the last node's value

B. It causes infinite loop

C. It throws an error on empty list

D. It incorrectly compares values

Solution

1. Step 1: Understand the loop condition

   The loop runs while head.next !== null, so it stops before the last node.

2. Step 2: Check if last node is checked

   Because loop stops before last node, last node's value is never checked, so target in last node is missed.

3. Final Answer:

   It misses checking the last node's value -> Option A

4. Quick Check:

   Loop condition excludes last node check [OK]

Hint: Loop until node is null, not node.next [OK]

Common Mistakes:

• Using head.next !== null instead of head !== null
• Assuming last node is checked inside loop

5. You need to frequently check if a user ID exists and also maintain the order of insertion. Which data structure is best suited for this in JavaScript?

hard

A. Array

B. Map

C. Linked List

D. Set

Solution

1. Step 1: Understand requirements

   We need fast existence check and order preservation of user IDs.

2. Step 2: Compare data structures

   Array preserves order but slow lookup (O(n)). Linked List preserves order but slow lookup (O(n)). Map preserves order and fast lookup by key and stores key-value pairs. Set preserves insertion order and fast lookup for unique values but does not store key-value pairs.

3. Step 3: Choose best fit

   Map stores key-value pairs, preserves insertion order, and offers O(1) lookup, making it ideal for checking existence and maintaining order.

4. Final Answer:

   Map -> Option B

5. Quick Check:

   Fast lookup + order + key-value = Map [OK]

Hint: Use Map for key-value pairs with order and fast lookup [OK]

Common Mistakes:

• Choosing Set when key-value pairs are needed
• Using Array and expecting fast lookup
• Confusing Linked List order with lookup speed