Collision Handling Using Open Addressing Linear Probing in DSA Python - Build from Scratch

Collision Handling Using Open Addressing Linear Probing

📖 Scenario: Imagine you are managing a small library's book catalog. Each book has a unique ID number. You want to store these IDs in a simple table so you can quickly find them later. Sometimes, two books might want to go into the same spot in the table. To handle this, you will use a method called linear probing to find the next empty spot.

🎯 Goal: You will build a simple hash table using a list to store book IDs. When a collision happens (two books want the same spot), you will use linear probing to find the next free spot. Finally, you will print the table showing where each book ID is stored.

📋 What You'll Learn

Create a list called hash_table with 7 empty slots represented by None

Create a list called book_ids with these exact values: 10, 20, 15, 7, 32

Write a function called hash_function that returns the index by taking the book ID modulo 7

Insert each book ID into hash_table using linear probing to handle collisions

Print the final hash_table showing the stored book IDs and empty slots as None

💡 Why This Matters

🌍 Real World

Hash tables with collision handling are used in many places like databases, caches, and memory management to store and find data quickly.

💼 Career

Understanding collision handling in hash tables is important for software developers working on efficient data storage, search engines, and system design.

1

Create the hash table and book IDs list

Create a list called hash_table with 7 None values to represent empty slots. Then create a list called book_ids with these exact values: 10, 20, 15, 7, 32.

DSA Python

# Create hash_table with 7 None values
# Create book_ids list with 10, 20, 15, 7, 32
# Your code here

Hint

Use [None] * 7 to create a list with 7 empty slots.

Write the exact list [10, 20, 15, 7, 32] for book IDs.

2

Define the hash function

Define a function called hash_function that takes a parameter key and returns key % 7.

DSA Python

hash_table = [None] * 7
book_ids = [10, 20, 15, 7, 32]

# Define hash_function(key) that returns key modulo 7
# Your code here

Hint

The hash function finds the index by using the remainder when dividing by 7.

3

Insert book IDs using linear probing

Write a for loop to go through each book_id in book_ids. For each book_id, find the index using hash_function(book_id). If the slot at that index in hash_table is None, insert the book_id there. If not, use linear probing by moving to the next index (wrap around to 0 after 6) until you find an empty slot, then insert the book_id.

DSA Python

hash_table = [None] * 7
book_ids = [10, 20, 15, 7, 32]

def hash_function(key):
    return key % 7

# Insert each book_id into hash_table using linear probing
# Your code here

Hint

Use a while loop to find the next empty slot if the first index is taken.

Remember to wrap around using modulo 7.

4

Print the final hash table

Write a print statement to display the hash_table list showing the stored book IDs and None for empty slots.

DSA Python

hash_table = [None] * 7
book_ids = [10, 20, 15, 7, 32]

def hash_function(key):
    return key % 7

for book_id in book_ids:
    index = hash_function(book_id)
    while hash_table[index] is not None:
        index = (index + 1) % 7
    hash_table[index] = book_id

# Print the hash_table
# Your code here

Hint

The printed list shows book IDs in their slots and None for empty slots.

Practice

1. What is the main idea behind linear probing in collision handling for hash tables?

easy

A. Double the size of the hash table when a collision occurs.

B. If a slot is occupied, check the next slot sequentially until an empty one is found.

C. Use a linked list at each slot to store multiple elements.

D. Rehash all elements using a new hash function.

Solution

1. Step 1: Understand linear probing concept

   Linear probing handles collisions by checking the next slot in order if the original slot is taken.

2. Step 2: Compare with other methods

   Other methods like chaining use linked lists, resizing, or rehashing, which are different from linear probing.

3. Final Answer:

   If a slot is occupied, check the next slot sequentially until an empty one is found. -> Option B

4. Quick Check:

   Linear probing = sequential slot check [OK]

Hint: Linear probing means try next slot until free [OK]

Common Mistakes:

• Confusing linear probing with chaining
• Thinking linear probing resizes the table
• Assuming rehashing is part of linear probing

2. Which of the following is the correct way to calculate the next index in linear probing for a hash table of size m when a collision occurs at index i?

easy

A. (i + 2) % m

B. (i * 2) % m

C. (i + 1) % m

D. (i - 1) % m

Solution

1. Step 1: Recall linear probing formula

   Linear probing moves to the next slot by adding 1 to the current index and taking modulo with table size.

2. Step 2: Apply modulo for wrap-around

   Using modulo ensures the index wraps around to the start if it reaches the end of the table.

3. Final Answer:

   (i + 1) % m -> Option C

4. Quick Check:

   Next index = (current + 1) mod size [OK]

Hint: Next slot = (current index + 1) mod table size [OK]

Common Mistakes:

• Adding 2 instead of 1 for next index
• Multiplying index instead of adding
• Not using modulo for wrap-around

3. Consider a hash table of size 5 using linear probing. The hash function is h(k) = k % 5. Insert keys 7, 12, 17 in order. What is the final state of the table?

medium

A. [None, None, 7, 12, 17]

B. [7, 12, 17, None, None]

C. [None, 7, 12, 17, None]

D. [7, None, 12, 17, None]

Solution

1. Step 1: Calculate initial positions

   h(7) = 7 % 5 = 2, h(12) = 12 % 5 = 2, h(17) = 17 % 5 = 2.

2. Step 2: Insert keys using linear probing

   Insert 7 at index 2. For 12, index 2 is taken, so try index 3. Insert 12 at index 3. For 17, indices 2 and 3 are taken, so insert at index 4.

3. Final Answer:

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

4. Quick Check:

   Keys placed at 2, 3, 4 with linear probing [OK]

Hint: Check hash index, then next free slot sequentially [OK]

Common Mistakes:

• Placing all keys at same index ignoring collisions
• Not probing to next slot after collision
• Miscomputing hash values

4. The following code snippet tries to insert keys into a hash table using linear probing. What is the bug?

def insert(table, key):
    m = len(table)
    index = key % m
    while table[index] is not None:
        index = (index + 1) % m
    table[index] = key

hash_table = [None]*5
insert(hash_table, 5)
insert(hash_table, 10)
insert(hash_table, 15)
insert(hash_table, 20)
insert(hash_table, 25)
insert(hash_table, 30)

medium

A. Infinite loop if table is full because no stop condition in while loop.

B. No bug; code works correctly for all insertions.

C. Wrong hash function used; should be key // m.

D. Table size should be dynamic, not fixed.

Solution

1. Step 1: Analyze insertion loop

   The while loop continues probing until it finds an empty slot but has no check for full table.

2. Step 2: Identify problem when table is full

   If all slots are occupied, the loop cycles endlessly, causing infinite loop.

3. Final Answer:

   Infinite loop if table is full because no stop condition in while loop. -> Option A

4. Quick Check:

   Full table causes infinite loop without exit [OK]

Hint: Check for full table to avoid infinite loop [OK]

Common Mistakes:

• Assuming hash function is wrong
• Ignoring infinite loop possibility
• Thinking dynamic size fixes this bug

5. You have a hash table of size 7 using linear probing. Insert keys [14, 21, 28, 35, 42] using hash function h(k) = k % 7. After all insertions, what is the index of key 42 in the table?

hard

A. 5

B. 0

C. 6

D. 4

Solution

1. Step 1: Calculate initial hash indices

   h(14)=0, h(21)=0, h(28)=0, h(35)=0, h(42)=0 (all keys hash to index 0).

2. Step 2: Insert keys using linear probing

   Insert 14 at 0. For 21, index 0 taken, try 1. Insert 21 at 1. For 28, indices 0 and 1 taken, insert at 2. For 35, insert at 3. For 42, insert at 4.

3. Step 3: Find index of key 42

   Key 42 is at index 4.

4. Final Answer:

   4 -> Option D

5. Quick Check:

   42 placed at first free slot after collisions [OK]

Hint: All keys collide; count steps from initial index [OK]

Common Mistakes:

• Assuming key stays at initial hash index
• Not probing sequentially after collisions
• Miscounting index after multiple collisions