Collision handling (chaining) in Data Structures Theory - Mini Project: Build & Apply

Collision handling (chaining)

📖 Scenario: Imagine you are designing a simple phone book that stores names and phone numbers. Sometimes, two people might have names that lead to the same storage spot. To handle this, you use a method called chaining, where each spot holds a list of entries.

🎯 Goal: You will build a basic structure to show how collision handling with chaining works by creating a hash table with lists to store multiple entries in the same spot.

📋 What You'll Learn

Create a hash table with fixed size and empty lists for each slot

Define a simple hash function to find the slot for a name

Add entries to the hash table using chaining to handle collisions

Show the final hash table structure with all entries stored

💡 Why This Matters

🌍 Real World

Hash tables with chaining are used in many software systems to store and quickly find data even when keys collide.

💼 Career

Understanding collision handling is important for software developers working with databases, caching systems, and performance-critical applications.

1

Create the hash table structure

Create a variable called hash_table that is a list with 5 empty lists inside it.

Data Structures Theory

hash_table = [[] for _ in range(5)]  # Create a list with 5 empty lists

Hint

Use a list comprehension to create 5 empty lists inside hash_table.

2

Define the hash function

Create a function called hash_function that takes a parameter key and returns the length of key modulo 5.

Data Structures Theory

def hash_function(key):
    # Your code here
    pass

Hint

The hash function uses the length of the key and divides by 5, returning the remainder.

3

Add entries using chaining

Use the hash_function to find the index for each name in the list entries = [("Anna", "123"), ("Bob", "456"), ("Clara", "789"), ("Dave", "012"), ("Eve", "345")]. Then add each tuple to the correct list inside hash_table.

Data Structures Theory

entries = [("Anna", "123"), ("Bob", "456"), ("Clara", "789"), ("Dave", "012"), ("Eve", "345")]

for name, number in entries:
    # Your code here
    pass

Hint

Loop over each entry, find the index using the hash function, then add the entry to the list at that index.

4

Complete the hash table setup

Add a final line that assigns the variable final_table to the current hash_table to represent the completed structure.

Data Structures Theory

final_table = hash_table  # Assign the completed hash table
# Your code here

Hint

This final step just saves the current hash table into final_table to show the completed chaining structure.

Practice

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

easy

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

B. Overwrite the existing item when a collision occurs

C. Resize the hash table immediately after a collision

D. Store collided items in a linked list at the same index

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 items in a linked list at that index, preserving all entries.

3. Final Answer:

   Store collided items in a linked list at the same index -> Option D

4. Quick Check:

   Chaining = linked list at index [OK]

Hint: Chaining means linked lists hold collisions at one spot [OK]

Common Mistakes:

• Thinking collisions overwrite existing data
• Confusing chaining with open addressing
• Assuming resizing happens immediately on collision

2. Which of the following is the correct way to represent chaining in a hash table?

easy

A. Each index holds a single value only

B. Each index holds a linked list of values

C. Each index holds a separate hash table

D. Each index holds a fixed-size array of values

Solution

1. Step 1: Recall chaining structure

   Chaining uses linked lists to store multiple items at one index.

2. Step 2: Match options to chaining

   Only Each index holds a linked list of values describes linked lists at each index, which is chaining.

3. Final Answer:

   Each index holds a linked list of values -> Option B

4. Quick Check:

   Chaining = linked list per index [OK]

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

Common Mistakes:

• Choosing single value per index (no chaining)
• Confusing chaining with nested hash tables
• Thinking arrays are used instead of lists

3. Consider a hash table using chaining with 5 buckets. The hash function is h(key) = key % 5. Insert keys 7, 12, 17, 22. What does the bucket at index 2 contain?

medium

A. [7, 12, 17, 22]

B. [7, 17]

C. [12, 22]

D. [2]

Solution

1. Step 1: Calculate hash for each key

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

2. Step 2: List keys in bucket 2

   Bucket 2 contains keys 7, 12, 17, 22.

3. Step 3: Verify which keys actually hash to 2

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

4. Step 4: Check options carefully

   [7, 17] lists [7, 17], but keys 12 and 22 also hash to 2, so [7, 17] is incomplete. [7, 12, 17, 22] lists all keys, which is correct.

5. Final Answer:

   [7, 12, 17, 22] -> Option A

6. Quick Check:

   All keys mod 5 = 2 [OK]

Hint: Apply mod function to keys to find bucket [OK]

Common Mistakes:

• Miscomputing modulo operation
• Assuming keys distribute to different buckets
• Confusing bucket index with key values

4. A hash table uses chaining but the linked list at one index is not updated correctly after insertion. What is the likely error?

medium

A. The new node is not linked to the existing list

B. The hash function returns different values for same key

C. The table size is too small

D. The keys are not unique

Solution

1. Step 1: Understand chaining insertion

   When inserting, the new node must link to the existing list at that index.

2. Step 2: Identify error from symptoms

   If the list is not updated, likely the new node was not linked properly.

3. Final Answer:

   The new node is not linked to the existing list -> Option A

4. Quick Check:

   Missing link causes list update failure [OK]

Hint: Check if new node links to list head [OK]

Common Mistakes:

• Blaming hash function for insertion errors
• Thinking table size causes linking issues
• Confusing key uniqueness with chaining errors

5. You have a hash table with chaining. If many keys hash to the same index, what is the best way to improve performance?

hard

A. Ignore collisions and overwrite old keys

B. Use a linked list with more nodes at that index

C. Increase the table size and rehash all keys

D. Store all keys in a single bucket

Solution

1. Step 1: Understand impact of many collisions

   Many keys in one bucket slow down search because linked list grows long.

2. Step 2: Improve performance by resizing

   Increasing table size reduces collisions by spreading keys across more buckets.

3. Step 3: Rehash keys after resizing

   Rehashing redistributes keys according to new table size for better balance.

4. Final Answer:

   Increase the table size and rehash all keys -> Option C

5. Quick Check:

   Resize + rehash reduces collisions [OK]

Hint: Resize table and rehash keys to reduce collisions [OK]

Common Mistakes:

• Adding more nodes without resizing
• Overwriting keys loses data
• Putting all keys in one bucket defeats hashing