Explain how a hash table works internally. How would you design one from scratch?
Hash tables are the most frequently used data structure in software engineering. Understanding their internals — hash functions, collision handling, and resizing — separates candidates who memorize APIs from those who truly understand data structures.
Explain the core idea: a hash function maps keys to array indices for O(1) average-case access.
Discuss collision resolution: chaining (linked lists at each bucket) vs open addressing (linear probing, quadratic probing, double hashing).
Cover load factor and dynamic resizing: when the load factor exceeds a threshold, double the array and rehash all entries.
Mention good hash function properties: deterministic, uniform distribution, fast to compute.
A hash table stores key-value pairs by computing a hash of the key to determine the array index. The core operation is index = hash(key) % array_size, giving O(1) average access. Collisions occur when different keys hash to the same index. I handle them with chaining — each bucket holds a linked list of entries — or open addressing, where I probe for the next empty slot. Chaining is simpler and degrades gracefully; open addressing has better cache performance but is trickier to implement correctly, especially with deletion. I maintain a load factor (entries / buckets). When it exceeds 0.75, I double the array size and rehash all existing entries — this amortized cost keeps operations at O(1). A good hash function distributes keys uniformly; for strings, I might use polynomial rolling hash. For my design, I would use an array of buckets with chaining, track the load factor, and resize at 0.75. I would also implement proper equals checking since different objects can have the same hash code.
Know the difference between chaining and open addressing — and when each is preferred.
Understand why resizing is amortized O(1) — interviewers often ask this.
Be ready to discuss how Java HashMap or Python dict handles collisions internally (treeification at bucket size 8 in Java 8+).
O(n) when all keys hash to the same bucket. This is why a good hash function with uniform distribution is critical.
Chaining stores collisions in a linked list at each bucket. Open addressing finds another empty slot in the array using a probing sequence. Chaining is simpler; open addressing is more cache-friendly.
Load factor (n/m) measures how full the table is. High load factors increase collision probability and degrade performance. Resizing at 0.75 balances space and speed.
HireMe AI listens to your interview in real-time, detects questions, and generates instant answer suggestions — so you never freeze up again.
Try HireMe AI Free