Hash Table Concept and Hash Functions in DSA Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a hash table?

A hash table is a data structure that stores key-value pairs. It uses a hash function to convert keys into an index where the value is stored, allowing fast data retrieval.

beginner

What is the role of a hash function in a hash table?

A hash function takes a key and returns an integer index. This index tells where to store or find the value in the hash table.

intermediate

What is a collision in a hash table?

A collision happens when two different keys produce the same index from the hash function. The hash table must handle collisions to store both values correctly.

intermediate

Name one common method to handle collisions in hash tables.

One common method is chaining, where each index stores a list of key-value pairs. If multiple keys map to the same index, they are stored in the list at that index.

intermediate

Why should a hash function distribute keys uniformly?

Uniform distribution helps avoid many keys clustering at the same index, which keeps data retrieval fast and efficient.

What does a hash function do in a hash table?

A Converts a key into an index

B Sorts the keys alphabetically

C Stores values directly

D Deletes keys from the table

A hash function converts a key into an index to store or find the value in the hash table.

What is a collision in a hash table?

A When two keys produce the same index

B When a key is missing

C When two keys have the same value

D When the table is empty

A collision happens when two different keys produce the same index from the hash function.

Which method stores multiple key-value pairs at the same index to handle collisions?

A Linear probing

B Sorting

C Chaining

D Rehashing

Chaining stores multiple key-value pairs in a list at the same index to handle collisions.

Why is uniform distribution important in a hash function?

A To reduce memory usage

B To make the table smaller

C To speed up sorting

D To avoid clustering of keys at the same index

Uniform distribution avoids many keys clustering at the same index, keeping retrieval fast.

What type of data structure is a hash table?

A A tree structure

B A key-value store

C A list of values

D A queue

A hash table stores data as key-value pairs for fast access.

Explain how a hash table uses a hash function to store and retrieve data.

Think about how a key becomes a position in the table.

Describe what a collision is in a hash table and one way to handle it.

Imagine two friends trying to sit on the same chair.

Practice

1. What is the main purpose of a hash function in a hash table?

easy

A. To encrypt the data stored in the table

B. To sort the keys in ascending order

C. To convert a key into an index for storing data

D. To count the number of elements in the table

Solution

1. Step 1: Understand the role of a hash function

   A hash function takes a key and converts it into a number that can be used as an index in the hash table.

2. Step 2: Compare with other options

   Sorting keys, encrypting data, or counting elements are not the main roles of a hash function in a hash table.

3. Final Answer:

   To convert a key into an index for storing data -> Option C

4. Quick Check:

   Hash function = key to index [OK]

Hint: Hash function maps keys to indexes fast [OK]

Common Mistakes:

• Thinking hash function sorts keys
• Confusing hash function with encryption
• Assuming hash function counts elements

2. Which of the following is the correct syntax to define a simple hash function in Python that returns the remainder of a key divided by 10?

easy

A. def hash_func(key): return key % 10

B. def hash_func(key): return key / 10

C. def hash_func(key): return key * 10

D. def hash_func(key): return key + 10

Solution

1. Step 1: Identify the correct modulus operation

   The hash function should return the remainder when key is divided by 10, which is done using the modulus operator '%'.

2. Step 2: Check syntax correctness

   def hash_func(key): return key % 10 uses 'return key % 10' which is correct syntax and logic. Other options use division, multiplication, or addition which do not produce the remainder.

3. Final Answer:

   def hash_func(key): return key % 10 -> Option A

4. Quick Check:

   Use % for remainder in hash function [OK]

Hint: Use % operator for remainder in hash functions [OK]

Common Mistakes:

• Using division instead of modulus
• Multiplying or adding instead of modulus
• Incorrect function syntax

3. What will be the output of the following code?

def simple_hash(key):
    return key % 5

hash_table = [None] * 5
keys = [12, 22, 17]
for key in keys:
    index = simple_hash(key)
    hash_table[index] = key
print(hash_table)

medium

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

B. [None, None, 17, None, None]

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

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

Solution

1. Step 1: Calculate hash indexes for each key

   12 % 5 = 2, 22 % 5 = 2, 17 % 5 = 2. All three keys map to the same index 2.

2. Step 2: Trace the assignments

   The code assigns directly to hash_table[index] with no collision handling, so later keys overwrite earlier ones at index 2: 12 -> 22 -> 17. Final state: [None, None, 17, None, None].

3. Final Answer:

   [None, None, 17, None, None] -> Option B

4. Quick Check:

   All keys hash to index 2, last key stored [OK]

Hint: Check hash index for each key carefully [OK]

Common Mistakes:

• Assuming keys store at different indexes without collision
• Ignoring overwriting in hash table
• Miscomputing modulus

4. Identify the error in the following hash function code:

def hash_func(key):
    return key // 10

hash_table = [None] * 10
index = hash_func(25)
hash_table[index] = 25
print(hash_table)

medium

A. No error, code runs correctly

B. hash_table size is too small for keys

C. Function should return key * 10 instead

D. Using integer division instead of modulus causes wrong indexing

Solution

1. Step 1: Understand the hash function logic

   The function uses integer division '//' which divides key by 10 and returns the quotient, not the remainder.

2. Step 2: Check impact on indexing

   For key=25, 25 // 10 = 2, which is a valid index but this is not a typical hash function behavior. Usually, modulus '%' is used to get remainder for index within table size.

3. Step 3: Identify the error

   Using '//' can cause indexes outside the hash table size if keys are large. Modulus '%' should be used to ensure index is within table size.

4. Final Answer:

   Using integer division instead of modulus causes wrong indexing -> Option D

5. Quick Check:

   Use % for index, not // [OK]

Hint: Use % to keep index within table size [OK]

Common Mistakes:

• Confusing integer division with modulus
• Ignoring table size limits
• Assuming code runs without error

5. You want to design a hash function for strings that returns an index between 0 and 9 for a hash table of size 10. Which of the following functions correctly implements this?

hard

A. def hash_func(s): return sum(ord(c) for c in s) % 10

B. def hash_func(s): return len(s) * 10

C. def hash_func(s): return ord(s[0])

D. def hash_func(s): return s.count('a')

Solution

1. Step 1: Understand the requirement

   The hash function must return an integer index between 0 and 9 for any string input.

2. Step 2: Analyze each option

   def hash_func(s): return sum(ord(c) for c in s) % 10 sums ASCII values of all characters and uses modulus 10 to keep index in range 0-9. def hash_func(s): return len(s) * 10 multiplies length by 10, which can exceed 9. def hash_func(s): return ord(s[0]) returns ASCII of first char, which can be larger than 9. def hash_func(s): return s.count('a') counts 'a's, which can be any number, possibly larger than 9.

3. Step 3: Choose correct function

   Only def hash_func(s): return sum(ord(c) for c in s) % 10 guarantees index in 0-9 range for any string.

4. Final Answer:

   def hash_func(s): return sum(ord(c) for c in s) % 10 -> Option A

5. Quick Check:

   Sum ASCII % table size for string hash [OK]

Hint: Sum ASCII codes and mod by table size [OK]

Common Mistakes:

• Using string length times 10 as index
• Using ASCII code directly without modulus
• Using character count without range check