Collision Handling Using Chaining in DSA C++ - Time & Space Complexity

Time Complexity: Collision Handling Using Chaining

O(n/k)

Understanding Time Complexity

When we use chaining to handle collisions in a hash table, we want to know how fast operations like search, insert, and delete run.

We ask: How does the time to do these operations grow as the number of items increases?

Scenario Under Consideration

Analyze the time complexity of searching for a key in a hash table using chaining.

// Search key in hash table with chaining
bool search(int key) {
  int index = hashFunction(key);
  Node* current = table[index];
  while (current != nullptr) {
    if (current->key == key) return true;
    current = current->next;
  }
  return false;
}
    

This code looks in the linked list at the hashed index to find the key.

Identify Repeating Operations

Look for loops or repeated steps that take time.

• Primary operation: Traversing the linked list at the hash index.
• How many times: Up to the length of the list at that index, which depends on collisions.

How Execution Grows With Input

As more items are added, lists at each index can get longer if the table size stays the same.

Input Size (n)	Approx. Operations
10	About 1 to 2 steps (short lists)
100	About 10 steps (longer lists)
1000	About 100 steps (even longer lists)

Pattern observation: The time grows roughly in direct proportion to the number of items per list.

Final Time Complexity

Time Complexity: O(n/k) where k is the number of buckets.

This means the time depends on how many items share the same bucket; more buckets mean faster operations.

Common Mistake

[X] Wrong: "Searching in a chained hash table is always O(1)."

[OK] Correct: If many keys collide into the same bucket, the linked list grows, making search slower than constant time.

Interview Connect

Understanding how chaining affects time helps you explain hash table performance clearly and shows you know how data structures behave in real use.

Self-Check

"What if we resized the hash table dynamically to keep the lists short? How would that affect the time complexity?"

Practice

1. What is the main idea behind collision handling using chaining in hash tables?

easy

A. Store all elements that hash to the same index in a linked list at that index

B. Resize the hash table when a collision occurs

C. Use a second hash function to find a new index

D. Ignore collisions and overwrite existing data

Solution

1. Step 1: Understand collision in hash tables

   When two keys hash to the same index, a collision occurs.

2. Step 2: Explain chaining method

   Chaining stores all collided elements in a linked list at that index to keep them separate.

3. Final Answer:

   Store all elements that hash to the same index in a linked list at that index -> Option A

4. Quick Check:

   Chaining = linked list at index [OK]

Hint: Chaining means linked list at each hash index [OK]

Common Mistakes:

• Thinking chaining resizes the table
• Confusing chaining with open addressing
• Ignoring collisions instead of handling them

2. Which of the following is the correct way to declare a hash table using chaining in C++?

easy

A. std::vector<int> hashTable(size);

B. std::list hashTable(size);

C. std::vector hashTable(size);

D. std::list<int> hashTable(size);

Solution

1. Step 1: Understand chaining data structure

   Chaining uses a list at each index, so a vector of lists is needed.

2. Step 2: Check syntax correctness

   std::vector creates a vector where each element is a list, perfect for chaining.

3. Final Answer:

   std::vector hashTable(size); -> Option C

4. Quick Check:

   Vector of lists = chaining hash table [OK]

Hint: Chaining = vector of lists in C++ [OK]

Common Mistakes:

• Using list of vectors instead of vector of lists
• Using vector of ints only (no chaining)
• Incorrect container nesting order

3. Consider the following code snippet using chaining for collision handling:

std::vector hashTable(5);
int hashFunction(int key) { return key % 5; }

// Insert keys
hashTable[hashFunction(7)].push_back(7);
hashTable[hashFunction(12)].push_back(12);
hashTable[hashFunction(17)].push_back(17);

// Print contents at index 2
for (int val : hashTable[2]) {
    std::cout << val << " ";
}

What will be the output?

medium

A. 7 12 17

B. 12 17

C. 7

D. No output

Solution

1. Step 1: Calculate hash indices for keys

   7 % 5 = 2, 12 % 5 = 2, 17 % 5 = 2. All keys go to index 2.

2. Step 2: Check what is printed at index 2

   All three keys (7, 12, 17) are stored in the list at index 2 and printed in insertion order.

3. Final Answer:

   7 12 17 -> Option A

4. Quick Check:

   Keys mod 5 = 2, print all at index 2 [OK]

Hint: Calculate key % size to find index [OK]

Common Mistakes:

• Forgetting all keys collide at index 2
• Printing keys at wrong index
• Assuming keys overwrite each other

4. The following code attempts to insert keys into a hash table using chaining but causes a runtime error:

std::vector hashTable;
int hashFunction(int key) { return key % 10; }

void insertKey(int key) {
    int index = hashFunction(key);
    hashTable[index].push_back(key);
}

int main() {
    insertKey(15);
    insertKey(25);
    return 0;
}

What is the error and how to fix it?

medium

A. hashFunction returns wrong index; change modulo to 5

B. hashTable is empty; initialize with size before insertions

C. push_back is wrong method; use insert instead

D. No error; code runs fine

Solution

1. Step 1: Identify cause of runtime error

   hashTable is declared but not sized, so accessing hashTable[index] causes out-of-range error.

2. Step 2: Fix by initializing hashTable size

   Initialize hashTable with size 10 (e.g., std::vector hashTable(10);) before insertions.

3. Final Answer:

   hashTable is empty; initialize with size before insertions -> Option B

4. Quick Check:

   Vector size must match hash range [OK]

Hint: Initialize vector size before accessing indices [OK]

Common Mistakes:

• Ignoring vector size causes crash
• Changing hash function unnecessarily
• Using wrong list methods

5. You have a hash table of size 7 using chaining. You insert keys: 10, 21, 17, 14, 28, 35.
After all insertions, which index will have the longest chain and what will be its contents?
Use hash function: index = key % 7.

hard

A. Index 0: 10 -> 21 -> 35

B. Index 3: 10 -> 17

C. Index 4: 21 -> 14

D. Index 0: 21 -> 14 -> 28 -> 35

Solution

1. Step 1: Calculate hash indices for each key

   10 % 7 = 3, 21 % 7 = 0, 17 % 7 = 3, 14 % 7 = 0, 28 % 7 = 0, 35 % 7 = 0.

2. Step 2: Group keys by index

   Index 0: 21, 14, 28, 35 (4 keys); Index 3: 10, 17 (2 keys).

3. Step 3: Identify longest chain and contents

   Index 0 has the longest chain with keys 21, 14, 28, 35 inserted in order.

4. Final Answer:

   Index 0: 21 -> 14 -> 28 -> 35 -> Option D

5. Quick Check:

   Keys mod 7 grouped; longest chain at index 0 [OK]

Hint: Calculate key % size, count keys per index [OK]

Common Mistakes:

• Miscomputing modulo results
• Mixing up indices and keys
• Ignoring insertion order in chain