When a room is full, walk down the hall

No extra room — take the next one down the hall

A hostel with strictly single-occupancy rooms cannot add a cot when a room is taken. Instead, the warden's rule is: try your assigned room; if it is occupied, check the next room down the hall; keep walking until an empty one turns up. Open addressing does exactly this — every slot in the table holds at most one key, and a collision is resolved by probing forward through the table itself, not by growing a list.

void insert(int table[], int key)
{
    int index = key % TABLE_SIZE;

    while (table[index] != EMPTY) {       /* linear probing */
        index = (index + 1) % TABLE_SIZE; /* Unit I's circular queue math */
    }
    table[index] = key;
}

Searching must retrace the same steps

Because a key may not sit at its computed slot at all, searching cannot simply check one slot and give up — it must probe the exact same sequence insertion would have used, checking each slot until the key is found or, critically, until an empty slot appears.

An empty slot is the honest end of the trail: if the key you want had ever been inserted, its probe sequence would have stopped at that same empty slot rather than continuing past it — so finding an empty slot proves the key was never placed. Stopping only when the whole table is full, instead, would force every failed search to check every single slot, which defeats the entire purpose of hashing.

int search(int table[], int key)
{
    int index = key % TABLE_SIZE;
    int start = index;

    while (table[index] != EMPTY) {
        if (table[index] == key) return index;   /* found */
        index = (index + 1) % TABLE_SIZE;
        if (index == start) break;                /* full loop, not found */
    }
    return NOT_FOUND;   /* hit EMPTY before finding it — never inserted */
}