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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare an array of 5 integers.

DSA C++

int arr[[1]];

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

A1

B10

C0

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 as size causes an empty array.

Using 10 creates a bigger array than needed.

The array size should be 5 to hold 5 integers.

2fill in blank

medium

Complete the code to find a value in a linked list by iterating nodes.

DSA C++

while (current != nullptr && current->value != [1]) {
    current = current->next;
}

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

Ahead

Btarget

Cnullptr

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing to head instead of target.

Comparing to nullptr which is a pointer, not a value.

We compare each node's value to the target value we want to find.

3fill in blank

hard

Fix the error in the hash map lookup code to get the value for a key.

DSA C++

auto it = map.find([1]);
if (it != map.end()) {
    return it->second;
} else {
    return -1;
}

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

Akey

Bvalue

Cmap

Dend

Attempts:

3 left

💡 Hint

Common Mistakes

Passing value instead of key to find.

Passing map or end which are not keys.

We must search the map using the key, not the value or other terms.

4fill in blank

hard

Fill both blanks to create a loop that searches an array for a target value.

DSA C++

for (int i = 0; i [1] n; i[2]) {
    if (arr[i] == target) {
        return i;
    }
}

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

A<

B++

C--

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<=' causes out-of-bounds access.

Using '--' decreases i causing infinite loop.

The loop runs from 0 up to but not including n, incrementing i by 1 each time.

5fill in blank

hard

Fill all three blanks to create a hash map insertion with key and value.

DSA C++

std::unordered_map<std::string, int> map;
map[[1]] = [2];
int val = map[[3]];

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

A"apple"

B5

D"banana"

Attempts:

3 left

💡 Hint

Common Mistakes

Using different keys for insertion and retrieval.

Not using quotes for string keys.

We insert value 5 for key "apple" and then retrieve it using the same key.

Practice

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

easy

A. Array

B. Stack

C. Linked List

D. Hash Map

Solution

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

   Hash Map uses hashing to find keys quickly, usually in constant time O(1). Arrays require searching elements, which is O(n) unless index is known. Linked Lists require traversal, also O(n).

2. Step 2: Compare average lookup times

   Hash Map average lookup is O(1), Array and Linked List average lookup is O(n). So Hash Map is fastest for key-based lookup.

3. Final Answer:

   Hash Map -> Option D

4. Quick Check:

   Fastest lookup = Hash Map [OK]

Hint: Hash Map lookup is usually O(1), faster than arrays or lists [OK]

Common Mistakes:

• Confusing array index access with key lookup
• Thinking linked list lookup is faster than array
• Assuming stack is good for key lookup

2. Which of the following is the correct way to declare a hash map in C++ using STL for integer keys and string values?

easy

A. std::unordered_map map;

B. std::map map;

C. std::hash_map map;

D. std::unordered_map map;

Solution

1. Step 1: Identify correct STL container for hash map

   In modern C++, std::unordered_map is the standard hash map container. std::hash_map is deprecated or non-standard.

2. Step 2: Check key and value types

   We want integer keys and string values, so std::unordered_map is correct. std::map map; uses std::map which is a balanced tree, not hash map. std::unordered_map map; swaps key and value types.

3. Final Answer:

   std::unordered_map map; -> Option A

4. Quick Check:

   Correct hash map syntax = std::unordered_map map; [OK]

Hint: Use std::unordered_map for hash maps in C++ [OK]

Common Mistakes:

• Using std::map instead of unordered_map for hash map
• Swapping key and value types
• Using deprecated std::hash_map

3. What will be the output of the following C++ code snippet?

#include <iostream>
#include <unordered_map>
int main() {
    std::unordered_map map = {{1, "one"}, {2, "two"}, {3, "three"}};
    if (map.find(2) != map.end()) {
        std::cout << map[2];
    } else {
        std::cout << "Not found";
    }
    return 0;
}

medium

A. three

B. Not found

C. two

D. Compilation error

Solution

1. Step 1: Understand the map initialization and lookup

   The unordered_map is initialized with keys 1, 2, 3 and their string values. The code checks if key 2 exists using find.

2. Step 2: Check the condition and output

   Since key 2 exists, map[2] returns "two" which is printed.

3. Final Answer:

   two -> Option C

4. Quick Check:

   Key 2 found, output = two [OK]

Hint: Check if key exists before accessing map to avoid errors [OK]

Common Mistakes:

• Assuming map[2] returns "Not found" if key missing
• Confusing find() return value
• Thinking unordered_map is ordered

4. The following code tries to find an element in a linked list but causes a runtime error. What is the main issue?

#include <iostream>
struct Node {
    int data;
    Node* next;
};

int main() {
    Node* head = nullptr;
    // No nodes added
    Node* current = head;
    while (current->data != 5) {
        current = current->next;
    }
    std::cout << "Found 5";
    return 0;
}

medium

A. Infinite loop because next is never updated

B. Dereferencing null pointer when list is empty

C. Missing return statement in main

D. Incorrect struct definition

Solution

1. Step 1: Analyze linked list initialization

   The list is empty (head is nullptr). The pointer current is set to nullptr.

2. Step 2: Identify cause of runtime error

   The code tries to access current->data without checking if current is nullptr, causing a null pointer dereference and runtime crash.

3. Final Answer:

   Dereferencing null pointer when list is empty -> Option B

4. Quick Check:

   Null pointer access causes runtime error [OK]

Hint: Always check pointer is not null before dereferencing [OK]

Common Mistakes:

• Ignoring null pointer checks
• Assuming list has elements without adding
• Confusing infinite loop with crash

5. You need to store a large dataset of user IDs (integers) and their names (strings) for fast lookup by ID. Which data structure is best and why? Choose the best option considering lookup speed, memory, and insertion time.

hard

A. Hash Map, because it offers average O(1) lookup and efficient insertion

B. Linked List, because it uses less memory and is easy to insert

C. Array, because it provides O(1) lookup by index

D. Binary Search Tree, because it keeps data sorted for fast lookup

Solution

1. Step 1: Evaluate array suitability

   Array lookup by index is O(1), but user IDs are keys, not indices, so array lookup is O(n) unless IDs are continuous and small, which is unlikely.

2. Step 2: Compare linked list and binary search tree

   Linked list lookup is O(n), slow for large data. Binary search tree lookup is O(log n), better but slower than hash map average O(1).

3. Step 3: Assess hash map advantages

   Hash map provides average O(1) lookup and insertion, ideal for large datasets with arbitrary keys like user IDs.

4. Final Answer:

   Hash Map, because it offers average O(1) lookup and efficient insertion -> Option A

5. Quick Check:

   Best for fast key lookup = Hash Map [OK]

Hint: Use hash map for fast key-based lookup and insertion [OK]

Common Mistakes:

• Assuming array is always fastest for lookup
• Ignoring hash map memory overhead
• Choosing linked list for fast lookup