Collision Handling Using Chaining in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to insert a new key into the hash table using chaining.

DSA C++

void insert(int key) {
    int index = key % TABLE_SIZE;
    table[index].[1](key);
}

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

Asize

Bpop_back

Cclear

Dpush_back

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop_back removes elements instead of adding.

Using clear deletes all elements.

Using size returns the number of elements, not insertion.

We use push_back to add the key to the linked list at the computed index.

2fill in blank

medium

Complete the code to search for a key in the hash table using chaining.

DSA C++

bool search(int key) {
    int index = key % TABLE_SIZE;
    for (int i = 0; i < table[index].size(); i++) {
        if (table[index][i] [1] key) {
            return true;
        }
    }
    return false;
}

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

A>

B!=

C==

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using != will check for inequality, which is incorrect here.

Using > or < does not check for equality.

We check if the current element equals the key to find it.

3fill in blank

hard

Fix the error in the code to delete a key from the hash table using chaining.

DSA C++

void remove(int key) {
    int index = key % TABLE_SIZE;
    for (auto it = table[index].begin(); it != table[index].end(); ++it) {
        if (*it [1] key) {
            table[index].erase(it);
            break;
        }
    }
}

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

A==

B>

C!=

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using != will erase the wrong elements.

Using > or < does not correctly identify the key.

We must check if the element pointed by iterator equals the key to erase it.

4fill in blank

hard

Fill both blanks to correctly initialize the hash table and insert keys using chaining.

DSA C++

#define TABLE_SIZE 10
std::vector<int> table[[1]];

void insert(int key) {
    int index = key % [2];
    table[index].push_back(key);
}

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

ATABLE_SIZE

B10

C5

Dkey

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different size for the array and modulo causes errors.

Using 'key' as size or modulo is incorrect.

The table size is 10, and the modulo operation uses TABLE_SIZE to find the index.

5fill in blank

hard

Fill all three blanks to implement a function that prints all keys in the hash table using chaining.

DSA C++

void printTable() {
    for (int i = 0; i < [1]; i++) {
        std::cout << "Bucket " << i << ": ";
        for (auto [2] : table[i]) {
            std::cout << [3] << " -> ";
        }
        std::cout << "null\n";
    }
}

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

ATABLE_SIZE

Bkey

Ck

Di

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'i' as the inner loop variable causes confusion.

Printing the wrong variable instead of the key.

We loop from 0 to TABLE_SIZE, use 'k' as the loop variable for elements, and print 'k'.

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