Collision Handling Using Chaining in DSA C - Build from Scratch

Collision Handling Using Chaining

📖 Scenario: Imagine you are building a simple phone book application that stores names and phone numbers. To quickly find a phone number by name, you use a hash table. Sometimes, two names might get the same spot in the table (a collision). To handle this, you will use chaining, which means each spot in the table holds a list of entries.

🎯 Goal: You will create a hash table with chaining to store and handle collisions of phone book entries. You will add entries and then print the table to see how collisions are handled.

📋 What You'll Learn

Create a hash table with 3 buckets using an array of linked lists

Define a struct for phone book entries with name and phone number

Implement a simple hash function that maps names to bucket indices

Insert entries into the hash table using chaining for collisions

Print the hash table showing all entries in each bucket

💡 Why This Matters

🌍 Real World

Hash tables with chaining are used in many applications like databases, caches, and phone books to quickly find data even when collisions happen.

💼 Career

Understanding collision handling is important for software engineers working on efficient data storage, retrieval systems, and performance optimization.

1

Create the phone book entry struct and hash table array

Define a struct called Entry with char name[20], char phone[15], and a pointer next to another Entry. Then create an array called hashTable of size 3 that holds pointers to Entry.

DSA C

// Define struct Entry and create hashTable array
// Your code here

Hint

Use typedef struct Entry to define the entry. Initialize hashTable with NULLs.

2

Create a hash function to map names to bucket indices

Write a function called hash that takes a char* called name and returns an int. The function should sum the ASCII values of the characters in name and return the sum modulo 3.

DSA C

#include 
#include 
#include 

typedef struct Entry {
    char name[20];
    char phone[15];
    struct Entry* next;
} Entry;

Entry* hashTable[3] = {NULL, NULL, NULL};

// Write the hash function below
// Your code here

Hint

Loop through each character in name, add its ASCII value to sum, then return sum % 3.

3

Insert entries into the hash table using chaining

Write a function called insert that takes char* name and char* phone. It should create a new Entry, copy the name and phone, compute the bucket index using hash, and insert the new entry at the start of the linked list in hashTable at that index.

DSA C

#include 
#include 
#include 

typedef struct Entry {
    char name[20];
    char phone[15];
    struct Entry* next;
} Entry;

Entry* hashTable[3] = {NULL, NULL, NULL};

int hash(char* name) {
    int sum = 0;
    for (int i = 0; name[i] != '\0'; i++) {
        sum += name[i];
    }
    return sum % 3;
}

// Write the insert function below
// Your code here

Hint

Create a new entry with malloc, copy the strings, find the bucket with hash, and insert at the front of the list.

4

Print the hash table showing all entries in each bucket

Write a function called printHashTable that loops over each bucket index from 0 to 2. For each bucket, print Bucket i: and then traverse the linked list printing each entry as name -> phone. Finally, call insert to add these entries: ("Alice", "123"), ("Bob", "456"), ("Clara", "789"), ("David", "321"), and then call printHashTable.

DSA C

#include 
#include 
#include 

typedef struct Entry {
    char name[20];
    char phone[15];
    struct Entry* next;
} Entry;

Entry* hashTable[3] = {NULL, NULL, NULL};

int hash(char* name) {
    int sum = 0;
    for (int i = 0; name[i] != '\0'; i++) {
        sum += name[i];
    }
    return sum % 3;
}

void insert(char* name, char* phone) {
    Entry* newEntry = (Entry*)malloc(sizeof(Entry));
    strcpy(newEntry->name, name);
    strcpy(newEntry->phone, phone);
    int index = hash(name);
    newEntry->next = hashTable[index];
    hashTable[index] = newEntry;
}

// Write printHashTable function and main calls below
// Your code here

Hint

Loop through each bucket, print the bucket number, then print each entry in the linked list. Insert the given entries before printing.

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. Replace the existing element with the new one when a collision occurs

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

D. Resize the hash table immediately when a collision happens

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, allowing multiple elements per slot.

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:

• Confusing chaining with open addressing
• Thinking collisions overwrite existing data
• Believing resizing happens on every collision

2. Which of the following is the correct way to declare a node structure for chaining in C?

easy

A. typedef struct Node { int key; Node* next; } Node;

B. struct Node { int key; int next; };

C. typedef struct Node { int key; struct Node* next; } Node;

D. struct Node { int key; struct Node next; };

Solution

1. Step 1: Check correct pointer usage in struct

   In C, to create a linked list node, the next pointer must be a pointer to the same struct type.

2. Step 2: Validate typedef syntax

   typedef struct Node { int key; struct Node* next; } Node; correctly uses struct Node* next; and typedefs the struct as Node.

3. Final Answer:

   typedef struct Node { int key; struct Node* next; } Node; -> Option C

4. Quick Check:

   Pointer to struct Node is struct Node* next [OK]

Hint: Use struct Node* for next pointer in C structs [OK]

Common Mistakes:

• Using struct Node next instead of pointer
• Missing typedef keyword or incorrect syntax
• Declaring next as int instead of pointer

3. Consider the following code snippet for inserting keys into a hash table using chaining. What will be the output after inserting keys 5, 15, and 25 if the hash function is key % 10?

typedef struct Node {
  int key;
  struct Node* next;
} Node;

Node* hashTable[10] = {NULL};

void insert(int key) {
  int index = key % 10;
  Node* newNode = malloc(sizeof(Node));
  newNode->key = key;
  newNode->next = hashTable[index];
  hashTable[index] = newNode;
}

// Insert keys
insert(5);
insert(15);
insert(25);

// Print keys at index 5
Node* temp = hashTable[5];
while(temp != NULL) {
  printf("%d -> ", temp->key);
  temp = temp->next;
}
printf("NULL\n");

medium

A. NULL

B. 5 -> 15 -> 25 -> NULL

C. 15 -> 25 -> 5 -> NULL

D. 25 -> 15 -> 5 -> NULL

Solution

1. Step 1: Calculate hash index for each key

   All keys 5, 15, 25 % 10 = 5, so all go to index 5.

2. Step 2: Trace insertion order in chaining

   Each new node is inserted at the head, so order is 25 (last inserted), then 15, then 5.

3. Final Answer:

   25 -> 15 -> 5 -> NULL -> Option D

4. Quick Check:

   New nodes added at head = 25 -> 15 -> 5 [OK]

Hint: New nodes go to head of list in chaining [OK]

Common Mistakes:

• Assuming insertion at tail instead of head
• Miscomputing hash index
• Printing keys in wrong order

4. The following code for inserting into a chained hash table has a bug. What is the bug?

void insert(int key) {
  int index = key % 10;
  Node newNode;
  newNode.key = key;
  newNode.next = hashTable[index];
  hashTable[index] = &newNode;
}

medium

A. No bug, code is correct

B. newNode is a local variable and will be lost after function ends

C. next pointer is not assigned properly

D. Hash function is incorrect

Solution

1. Step 1: Identify variable scope issue

   newNode is declared as a local variable on the stack inside insert function.

2. Step 2: Explain why this causes a bug

   After function returns, newNode memory is invalid, so hashTable points to invalid memory.

3. Final Answer:

   newNode is a local variable and will be lost after function ends -> Option B

4. Quick Check:

   Local variable address stored = invalid pointer [OK]

Hint: Use malloc for nodes, not local variables [OK]

Common Mistakes:

• Ignoring variable lifetime
• Thinking hash function is wrong
• Assuming next pointer assignment is incorrect

5. You have a hash table of size 7 using chaining. You insert keys: 10, 21, 17, 14, 28. The hash function is key % 7. After all insertions, which index will have the longest chain and what will be the order of keys in that chain if new nodes are inserted at the head?

hard

A. Index 0: 28 -> 14 -> 21 -> NULL

B. Index 3: 17 -> 14 -> 28 -> NULL

C. Index 3: 14 -> 17 -> 28 -> NULL

D. Index 4: 10 -> 21 -> NULL

Solution

1. Step 1: Compute hash index for each key

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

2. Step 2: Group keys by index and order insertion at head

   Index 0 keys inserted in order: 21, then 14, then 28 (last inserted at head). So chain at index 0 is 28 -> 14 -> 21 -> NULL.
   Index 3 keys are 10 and 17.

3. Final Answer:

   Index 0: 28 -> 14 -> 21 -> NULL -> Option A

4. Quick Check:

   Longest chain at index 0 with keys inserted at head [OK]

Hint: Calculate key % size, insert new nodes at head [OK]

Common Mistakes:

• Miscomputing hash indexes
• Mixing up insertion order in chains
• Choosing wrong index for longest chain