Hash Map vs Array vs Linked List for Lookup in DSA C++ - Compare & Choose

Challenge - 5 Problems

❓ Predict Output

intermediate

Lookup Time Comparison: Array vs Linked List

Consider the following C++ code that searches for the value 5 in an array and a linked list. What is the output?

DSA C++

#include <iostream>

int arr[] = {1, 3, 5, 7, 9};
struct Node {
  int val;
  Node* next;
};
Node* head = new Node{1, new Node{3, new Node{5, new Node{7, new Node{9, nullptr}}}}};

int searchArray(int* arr, int size, int target) {
  for (int i = 0; i < size; i++) {
    if (arr[i] == target) return i;
  }
  return -1;
}

int searchLinkedList(Node* head, int target) {
  int index = 0;
  while (head != nullptr) {
    if (head->val == target) return index;
    head = head->next;
    index++;
  }
  return -1;
}

int main() {
  int idxArr = searchArray(arr, 5, 5);
  int idxList = searchLinkedList(head, 5);
  std::cout << idxArr << " " << idxList << std::endl;
  return 0;
}

A 3 3

B -1 2

C 2 2

D 2 -1

💡 Hint

Remember that array indexing starts at 0 and linked list traversal counts nodes from the head.

The value 5 is at index 2 in the array (0-based). The linked list nodes are also counted from 0, so 5 is at index 2 there as well.

🧠 Conceptual

intermediate

Lookup Efficiency in Hash Map vs Array vs Linked List

Which data structure generally provides the fastest lookup time for finding an element by key?

A All have the same lookup time

B Linked List

C Array

D Hash Map

💡 Hint

Think about average time complexity for lookup in each data structure.

Hash maps provide average O(1) lookup time by key, arrays provide O(n) unless the index is known, and linked lists provide O(n) lookup time.

❓ Predict Output

advanced

Hash Map Lookup Collision Handling Output

Given the following simplified hash map code with chaining, what will be printed after inserting keys 1, 11, and 21 and then searching for key 11?

DSA C++

#include <iostream>

struct Node {
  int key;
  Node* next;
};

Node* hashTable[10] = {nullptr};

void insert(int key) {
  int index = key % 10;
  Node* newNode = new Node{key, hashTable[index]};
  hashTable[index] = newNode;
}

bool search(int key) {
  int index = key % 10;
  Node* curr = hashTable[index];
  while (curr != nullptr) {
    if (curr->key == key) return true;
    curr = curr->next;
  }
  return false;
}

int main() {
  insert(1);
  insert(11);
  insert(21);
  std::cout << (search(11) ? "Found" : "Not Found") << std::endl;
  return 0;
}

A Found

B Not Found

C Runtime Error

D Compilation Error

💡 Hint

Check how keys are inserted and how collisions are handled in the linked list at each bucket.

Keys 1, 11, and 21 all hash to index 1 (key % 10). They are inserted at the head of the linked list at that bucket. Searching for 11 finds it in the chain, so 'Found' is printed.

🧠 Conceptual

advanced

Why Linked List Lookup is Slower Than Array Lookup

Why is lookup by value generally slower in a linked list compared to an array?

A Because linked lists require traversal node by node, while arrays allow direct index access

B Because linked lists store elements in contiguous memory

C Because arrays use hashing internally

D Because linked lists have built-in sorting

💡 Hint

Think about how you access elements in each data structure.

Arrays store elements in contiguous memory, so accessing by index is direct and fast. Linked lists require visiting each node one by one until the target is found, which is slower.

❓ Predict Output

expert

Combined Lookup Scenario Output

What is the output of the following C++ code that uses an array, linked list, and unordered_map to lookup the value 7?

DSA C++

#include <iostream>
#include <unordered_map>
#include <string>

struct Node {
  int val;
  Node* next;
};

int main() {
  int arr[] = {2, 4, 6, 8};
  Node* head = new Node{1, new Node{3, new Node{5, nullptr}}};
  std::unordered_map<int, std::string> map = {{7, "seven"}, {8, "eight"}};

  // Search array
  bool foundArr = false;
  for (int i = 0; i < 4; i++) {
    if (arr[i] == 7) {
      foundArr = true;
      break;
    }
  }

  // Search linked list
  bool foundList = false;
  Node* curr = head;
  while (curr != nullptr) {
    if (curr->val == 7) {
      foundList = true;
      break;
    }
    curr = curr->next;
  }

  // Search hash map
  bool foundMap = map.find(7) != map.end();

  std::cout << foundArr << " " << foundList << " " << foundMap << std::endl;
  return 0;
}

A 1 0 1

B 0 0 1

C 0 1 0

D 1 1 0

💡 Hint

Check each data structure separately for the presence of 7.

The array does not contain 7, so foundArr is 0. The linked list nodes are 1,3,5, so foundList is 0. The hash map contains key 7, so foundMap is 1.

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