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

Time Complexity: Hash Map vs Array vs Linked List for Lookup

O(n) for Array and Linked List, O(1) average for Hash Map

Understanding Time Complexity

We want to understand how fast we can find a value in different data structures.

How does the time to find something change as the data grows?

Scenario Under Consideration

Analyze the time complexity of lookup operations in these data structures.

// Lookup in array
bool lookupArray(int arr[], int n, int target) {
  for (int i = 0; i < n; i++) {
    if (arr[i] == target) return true;
  }
  return false;
}

// Lookup in linked list
struct Node {
  int val;
  Node* next;
};

bool lookupLinkedList(Node* head, int target) {
  Node* current = head;
  while (current != nullptr) {
    if (current->val == target) return true;
    current = current->next;
  }
  return false;
}

// Lookup in hash map (simplified)
#include <unordered_map>
bool lookupHashMap(std::unordered_map<int,int>& map, int target) {
  return map.find(target) != map.end();
}
    

This code shows how we search for a value in an array, a linked list, and a hash map.

Identify Repeating Operations

Look at what repeats when searching:

• Array: Loop through each element until found or end.
• Linked List: Traverse nodes one by one until found or end.
• Hash Map: Use a direct lookup using a hash function (no loop in average case).
• Dominant operation: The repeated checking of elements or nodes in array and list; single hash calculation and lookup in hash map.

How Execution Grows With Input

As the number of items grows, how many checks do we do?

Input Size (n)	Array/Linked List Checks	Hash Map Checks
10	Up to 10 checks	About 1 check
100	Up to 100 checks	About 1 check
1000	Up to 1000 checks	About 1 check

Pattern observation: Array and linked list checks grow linearly with input size; hash map lookup stays almost constant.

Final Time Complexity

Time Complexity: O(n) for Array and Linked List, O(1) average for Hash Map

This means searching in array or list takes longer as data grows, but hash map stays fast on average.

Common Mistake

[X] Wrong: "Hash map lookup always takes the same time no matter what."

[OK] Correct: Sometimes hash maps have collisions causing slower lookups, but on average they are fast.

Interview Connect

Knowing these differences helps you pick the right data structure and explain your choices clearly in interviews.

Self-Check

"What if the array was sorted? How would the time complexity of lookup change?"

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