Hash Map vs Array vs Linked List for Lookup in DSA C++ - Key Differences

Recall & Review

beginner

What is the average time complexity of lookup in a Hash Map?

The average time complexity of lookup in a Hash Map is O(1), meaning it can find an element very quickly on average.

beginner

How does lookup time in an Array compare to a Linked List?

Lookup in an Array is O(1) if you know the index, but O(n) if you search by value. In a Linked List, lookup by value is always O(n) because you must check each element one by one.

beginner

Why is lookup in a Linked List slower than in a Hash Map?

A Linked List stores elements in a chain, so to find an element, you must check each node one by one, leading to O(n) time. A Hash Map uses a key to jump directly to the element, making lookup O(1) on average.

beginner

What is a key advantage of using an Array for lookup?

An Array allows direct access to elements by index in O(1) time, which is very fast if you know the position of the element.

intermediate

When might a Linked List be preferred over an Array or Hash Map despite slower lookup?

A Linked List is preferred when you need fast insertions and deletions at any position without shifting elements, which Arrays require. Hash Maps do not maintain order, but Linked Lists do.

What is the average lookup time complexity of a Hash Map?

A O(n)

B O(1)

C O(log n)

D O(n log n)

Hash Maps provide average O(1) lookup by using keys to directly access values.

Which data structure allows direct access to elements by index?

A Array

B Hash Map

C Linked List

D Stack

Arrays allow direct access to elements by their index in O(1) time.

Why is lookup in a Linked List slower than in an Array?

A Because Linked Lists store elements in a chain and require traversal

B Because Linked Lists use hashing

C Because Arrays are unordered

D Because Linked Lists have direct access

Linked Lists require checking each node one by one, making lookup O(n).

Which data structure is best for fast insertions and deletions at any position?

A Array

B Hash Map

C Linked List

D Binary Search Tree

Linked Lists allow fast insertions and deletions without shifting elements.

If you need to find an element by value quickly, which data structure is usually fastest?

A Array

B Linked List

C Queue

D Hash Map

Hash Maps provide fast lookup by key, usually faster than searching arrays or linked lists.

Explain the differences in lookup time complexity between Hash Map, Array, and Linked List.

Think about how each data structure accesses elements.

Describe scenarios where you would choose a Linked List over an Array or Hash Map despite slower lookup.

Consider operations other than lookup.

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