Hash Table Visualizer

hash(key) = key mod m          // numbershash(word): h = 0; for each char: h = (h × 31 + code) mod m // Separate chaining: each bucket holds a linked listinsert(key):  i = hash(key)  if key is already in buckets[i]: return  append key to buckets[i]search(key): walk the list buckets[hash(key)]delete(key): unlink key from buckets[hash(key)] // Linear probing: one key per slotinsert(key):  i = hash(key)  while table[i] holds another key    i = (i + 1) mod m  table[i] = keysearch(key):  i = hash(key); while table[i] is not empty    if table[i] = key: return i; i = (i + 1) mod m  return not founddelete(key): find it, then mark the slot "deleted"

// Separate chaining
class HashTable {
    std::vector<std::list<int>> buckets;
public:
    HashTable(int m = 11) : buckets(m) {}
    int hash(int key) const { return key % buckets.size(); }
    void insert(int key) {
        auto& b = buckets[hash(key)];
        for (int k : b) if (k == key) return;
        b.push_back(key);
    }
    bool contains(int key) const {
        for (int k : buckets[hash(key)]) if (k == key) return true;
        return false;
    }
    void remove(int key) { buckets[hash(key)].remove(key); }
};
// In real code: std::unordered_map / std::unordered_set (chaining)

// Linear probing
class HashTable {
    private final Integer[] table;
    private static final Integer DELETED = Integer.MIN_VALUE;
    HashTable(int m) { table = new Integer[m]; }
    int hash(int key) { return key % table.length; }
    void insert(int key) {
        int i = hash(key);
        for (int t = 0; t < table.length; t++) {
            if (table[i] == null || table[i].equals(DELETED) || table[i] == key) { table[i] = key; return; }
            i = (i + 1) % table.length;
        }
        throw new IllegalStateException("table full");
    }
    int find(int key) {
        int i = hash(key);
        for (int t = 0; t < table.length && table[i] != null; t++) {
            if (table[i] == key) return i;
            i = (i + 1) % table.length;
        }
        return -1;
    }
    void remove(int key) { int i = find(key); if (i >= 0) table[i] = DELETED; }
}
// In real code: HashMap / HashSet

class HashTable:
    """Separate chaining with Python lists as buckets."""
    def __init__(self, m=11):
        self.buckets = [[] for _ in range(m)]

    def _hash(self, key):
        if isinstance(key, int):
            return key % len(self.buckets)
        h = 0
        for ch in key:
            h = (h * 31 + ord(ch)) % len(self.buckets)
        return h

    def insert(self, key):
        b = self.buckets[self._hash(key)]
        if key not in b:
            b.append(key)

    def contains(self, key):
        return key in self.buckets[self._hash(key)]

    def delete(self, key):
        b = self.buckets[self._hash(key)]
        if key in b:
            b.remove(key)

# In real code: dict and set (open addressing inside)

class HashTable {
  constructor(m = 11) { this.buckets = Array.from({ length: m }, () => []); }
  hash(key) {
    if (typeof key === 'number') return key % this.buckets.length;
    let h = 0;
    for (const ch of key) h = (h * 31 + ch.codePointAt(0)) % this.buckets.length;
    return h;
  }
  insert(key) {
    const b = this.buckets[this.hash(key)];
    if (!b.includes(key)) b.push(key);
  }
  has(key) { return this.buckets[this.hash(key)].includes(key); }
  delete(key) {
    const b = this.buckets[this.hash(key)];
    const i = b.indexOf(key);
    if (i >= 0) b.splice(i, 1);
  }
}
// In real code: Map and Set