hashTable.definition

// Java
class HashTable {
    Integer[] table;
    boolean[] deleted;
    int size;

    HashTable(int capacity) {
        table = new Integer[capacity];
        deleted = new boolean[capacity];
        size = 0;
    }

    int hash(int key) {
        return ((key % table.length) + table.length) % table.length;
    }

    void insert(int key) {
        int index = hash(key);
        int i = 0;
        while (table[index] != null && !deleted[index]) {
            i++;
            index = (hash(key) + i) % table.length; // Linear probing
        }
        table[index] = key;
        deleted[index] = false;
        size++;
    }
}

# Python
class HashTable:
    def __init__(self, capacity):
        self.table = [None] * capacity
        self.deleted = [False] * capacity
        self.size = 0

    def hash(self, key):
        return key % len(self.table)

    def insert(self, key):
        index = self.hash(key)
        i = 0
        while self.table[index] is not None and not self.deleted[index]:
            i += 1
            index = (self.hash(key) + i) % len(self.table)  # Linear probing
        self.table[index] = key
        self.deleted[index] = False
        self.size += 1

// C++
class HashTable {
    vector<int> table;
    vector<bool> occupied;
    vector<bool> deleted;
    int capacity;

public:
    HashTable(int cap) : capacity(cap) {
        table.resize(cap);
        occupied.resize(cap, false);
        deleted.resize(cap, false);
    }

    int hash(int key) {
        return ((key % capacity) + capacity) % capacity;
    }

    void insert(int key) {
        int index = hash(key);
        int i = 0;
        while (occupied[index] && !deleted[index]) {
            i++;
            index = (hash(key) + i) % capacity; // Linear probing
        }
        table[index] = key;
        occupied[index] = true;
        deleted[index] = false;
    }
};

// JavaScript
class HashTable {
  constructor(capacity) {
    this.table = new Array(capacity).fill(null);
    this.deleted = new Array(capacity).fill(false);
    this.size = 0;
  }

  hash(key) {
    return ((key % this.table.length) + this.table.length) % this.table.length;
  }

  insert(key) {
    let index = this.hash(key);
    let i = 0;
    while (this.table[index] !== null && !this.deleted[index]) {
      i++;
      index = (this.hash(key) + i) % this.table.length; // Linear probing
    }
    this.table[index] = key;
    this.deleted[index] = false;
    this.size++;
  }
}