Q.Use the hash function: h(element)= element%11 to store the collection of numbers: [44, 121, 55, 33, 110, 77, 22, 66] in a hash table. Display the hash table created. Search if the values 11, 44, 88 and 121 are present in the hash table, and display the search results.

This is a plain theory / code task — you are asked to construct a hash table using a given hash function, display it, and then search for specific values.

Hash Table Construction

We use the hash function $h(\text{element}) = \text{element} \bmod 11$. The table has 11 slots (indices 0 through 10). Collisions are resolved by linear probing — if a slot is occupied, we move to the next empty slot (wrapping around if needed).

Insert each number in the given order:

• 44: $44 \bmod 11 = 0$ → slot 0 is empty → place 44 at index 0.
• 121: $121 \bmod 11 = 0$ → slot 0 is occupied → probe to slot 1 (empty) → place 121 at index 1.
• 55: $55 \bmod 11 = 0$ → slot 0 occupied, slot 1 occupied → slot 2 empty → place 55 at index 2.
• 33: $33 \bmod 11 = 0$ → slots 0,1,2 occupied → slot 3 empty → place 33 at index 3.
• 110: $110 \bmod 11 = 0$ → slots 0–3 occupied → slot 4 empty → place 110 at index 4.
• 77: $77 \bmod 11 = 0$ → slots 0–4 occupied → slot 5 empty → place 77 at index 5.
• 22: $22 \bmod 11 = 0$ → slots 0–5 occupied → slot 6 empty → place 22 at index 6.
• 66: $66 \bmod 11 = 0$ → slots 0–6 occupied → slot 7 empty → place 66 at index 7.

The final hash table:

Search Results

For each search value, compute $h(\text{value})$ and probe linearly until we find the value or hit an empty slot (meaning the value is absent).

• Search for 11: $11 \bmod 11 = 0$ → slot 0 has 44 (not 11), slot 1 has 121, slot 2 has 55, slot 3 has 33, slot 4 has 110, slot 5 has 77, slot 6 has 22, slot 7 has 66, slot 8 is empty → not found.
• Search for 44: $44 \bmod 11 = 0$ → slot 0 has 44 → found.
• Search for 88: $88 \bmod 11 = 0$ → slot 0 has 44, slot 1 has 121, slot 2 has 55, slot 3 has 33, slot 4 has 110, slot 5 has 77, slot 6 has 22, slot 7 has 66, slot 8 is empty → not found.
• Search for 121: $121 \bmod 11 = 0$ → slot 0 has 44 (not 121), slot 1 has 121 → found.

Python Implementation

class HashTable:
    def __init__(self, size=11):
        self.size = size
        self.table = [None] * size

    def hash_function(self, key):
        return key % self.size

    def insert(self, value):
        index = self.hash_function(value)
        while self.table[index] is not None:
            index = (index + 1) % self.size …

This is a hash table construction and search problem. The core idea is that a hash table gives us near-constant-time lookups by using a function to compute where an element should be stored. When two elements map to the same slot (a collision), we need a strategy — here, the natural choice is linear probing: if a slot is occupied, try the next one (wrapping around if needed).

We have 11 slots (indices 0 through 10) because the hash function uses modulo 11. The numbers to insert are: 44, 121, 55, 33, 110, 77, 22, 66.

Let's build the table step by step.

Insert 44: 44 % 11 = 0. Slot 0 is empty → store 44 at index 0.

Insert 121: 121 % 11 = 0. Slot 0 is occupied. Linear probe: check slot 1 → empty → store 121 at index 1.

Insert 55: 55 % 11 = 0. Slot 0 occupied, slot 1 occupied, slot 2 empty → store 55 at index 2.

Insert 33: 33 % 11 = 0. Slots 0,1,2 occupied, slot 3 empty → store 33 at index 3.

Insert 110: 110 % 11 = 0. Slots 0,1,2,3 occupied, slot 4 empty → store 110 at index 4.

Insert 77: 77 % 11 = 0. Slots 0–4 occupied, slot 5 empty → store 77 at index 5.

Insert 22: 22 % 11 = 0. Slots 0–5 occupied, slot 6 empty → store 22 at index 6.

Insert 66: 66 % 11 = 0. Slots 0–6 occupied, slot 7 empty → store 66 at index 7.

The final hash table (indices 0 to 10) is:

Now, searching. For each target, we compute its hash index, then probe linearly until we either find it or hit an empty slot (meaning it's absent).

Search for 11: 11 % 11 = 0. Check slot 0: 44 ≠ 11. Slot 1: 121 ≠ 11. Slot 2: 55 ≠ 11. Slot 3: 33 ≠ 11. Slot 4: 110 ≠ 11. Slot 5: 77 ≠ 11. Slot 6: 22 ≠ 11. Slot 7: 66 ≠ 11. Slot 8: empty → stop. Not found.

Search for 44: 44 % 11 = 0. Slot 0: 44 == 44 → Found at index 0.

Search for 88: 88 % 11 = 0. Check slot 0: 44 ≠ 88. Slot 1: 121 ≠ 88. Slot 2: 55 ≠ 88. Slot 3: 33 ≠ 88. Slot 4: 110 ≠ 88. Slot 5: 77 ≠ 88. Slot 6: 22 ≠ 88. Slot 7: 66 ≠ 88. Slot 8: empty → stop. Not found.

Search for 121: 121 % 11 = 0. Slot 0: 44 ≠ 121. Slot 1: 121 == 121 → Found at index 1.

Here's the Python code that implements this:

class HashTable:
    def __init__(self, size=11):
        self.size = size
        self.table = [None] * size

    def hash_function(self, key):
        return key % self.size

    def insert(self, key):
        index = self.hash_function(key)
        # Linear probing: find the next empty slot
        while self.table[index] is not None:
            index = (index + 1) % self.size
        self.table[index] = key

    def search(self, key): …