Вы привели структуру записи:
typedef struct { int key; int used; } Entry;
Entry table$$SIZE$$;

Ниже — разъяснение и пример корректной реализации хэш-таблицы с открытой адресацией и двойным хешированием $doublehashing$. Важно: поле used должно иметь три состояния $EMPTY,OCCUPIED,DELETED$, иначе удаление работать не будет корректно — при простом 0/1 вы потеряете возможность продолжать поиск через удалённые слоты.

Основные моменты

Две хеш-функции: h1$k$ = k % SIZE, h2$k$ должно быть ненулевым и по возможности взаимно простым с SIZE. Часто берут h2$k$ = 1 + $k$ при простом SIZE.Индекс для i-й попытки: idx = $h1(k)+i\ast h2(k)$ % SIZE.Поиск: если попали в EMPTY — ключа нет, можно остановиться; если OCCUPIED и ключ совпал — найден; если DELETED или OCCUPIED с другим ключом — продолжаем.Вставка: при обходе запоминаем индекс первой DELETED ячейки; если находим EMPTY — вставляем либо в первую DELETED $еслибыла$, либо в этот EMPTY; если найден совпадающий ключ — можно обновить или отказать.Удаление: найденную OCCUPIED ячейку помечаем DELETED.

Пример кода $наглядный,минимальный$:

define SIZE 101 / лучше простое /define EMPTY 0define OCCUPIED 1define DELETED 2

typedef struct {
int key;
int used; / EMPTY, OCCUPIED, DELETED /
} Entry;

Entry table$$SIZE$$;

void init_table$void$ {
for (int i = 0; i < SIZE; ++i) table$$i$$.used = EMPTY;
}

static int h1$intkey$ {
return $key$ % SIZE;
}

static int h2$intkey$ {
/ гарантируем ненулевой шаг, лучше если SIZE простое: 1 + key % $SIZE-1$ /
return 1 + $(key$;
}

/ Поиск индекса ключа, возвращает индекс либо -1 если не найден /
int search$intkey$ {
int start = h1$key$;
int step = h2$key$;
for (int i = 0, idx = start; i < SIZE; ++i, idx = (idx + step) % SIZE) {
if $table[idx].used==EMPTY$ return -1; / дальше пусто — нет ключа /
if (table[idx].used == OCCUPIED && table[idx].key == key) return idx;
/ если DELETED или OCCUPIED другой ключ — продолжаем /
}
return -1;
}

/ Вставка: возвращает 0 — успешно, 1 — ключ уже есть, -1 — таблица полна /
int insert$intkey$ {
int start = h1$key$;
int step = h2$key$;
int first_deleted = -1;
for (int i = 0, idx = start; i < SIZE; ++i, idx = (idx + step) % SIZE) {
if $table[idx].used==OCCUPIED$ {
if $table[idx].key==key$ return 1; / уже есть /
} else if $table[idx].used==DELETED$ {
if $firs{t}_{d}eleted==-1$ first_deleted = idx;
} else { / EMPTY /
int pos = $firs{t}_{d}eleted!=-1$ ? first_deleted : idx;
table$$pos$$.key = key;
table$$pos$$.used = OCCUPIED;
return 0;
}
}
/ если цикл кончился, таблица либо заполнена OCCUPIED, либо только DELETED;
если был DELETED — вставляем туда /
if $firs{t}_{d}eleted!=-1$ {
table$$firs{t}_{d}eleted$$.key = key;
table$$firs{t}_{d}eleted$$.used = OCCUPIED;
return 0;
}
return -1; / полна /
}

/ Удаление: возвращает 0 — успешно, -1 — не найден /
int delete$intkey$ {
int idx = search$key$;
if $idx==-1$ return -1;
table$$idx$$.used = DELETED;
return 0;
}

Замечания и рекомендации

Лучше, чтобы SIZE было простым числом — тогда формула h2 = 1 + $k$ гарантирует, что шаг и SIZE взаимно просты и весь массив будет пройден.Если не хотите трёх состояний, можно хранить особое значение ключа как «пусто», но это неудобно и ненадёжно для общих ключей.При интенсивных операциях удаления может расти число DELETED ячеек → периодически полезно делать rehash $пересоздатьтаблицуивставитьтолькоOCCUPIEDэлементы$.Для более качественного хеширования используйте хорошие хеш-функции для int $например,перемешиваниебитов$ перед применением модификаторов.

Если хотите, могу дать:

версию кода с обработкой ошибок и тестовым main;пример h2 для случая, когда SIZE — степень двойки;доказательство, почему нужно три состояния.