A hash table turns a key into an array index with a hash function, then stores a key-value pair at that slot. Because different keys can hash to the same index, every real implementation needs a collision resolution strategy. In this topic you will build the structure yourself in JavaScript: a HashTable class holding an array of buckets, a hash function that converts keys into valid indices, and set, get, remove, and keys methods that use separate chaining — each bucket holding a list of entries rather than a single value.
This hands-on work matters because it makes the theory concrete. Once you have written the loop that walks a bucket's chain looking for a matching key, the claim that lookup is O(1) on average but O(n) in the worst case stops being abstract: the length of that chain is exactly what determines the cost. Writing the remove method also exposes why deletion is simpler under chaining than under open addressing.
The videos below are from a Java-based data structures series, so treat them as language-neutral blueprints rather than copy-and-paste code. While watching, focus on the structure of the decisions — how the index is computed and kept within array bounds, how the code distinguishes "bucket is empty" from "bucket has a chain," and how an existing key is updated rather than duplicated. Then translate those same steps into JavaScript, using arrays and objects (or Map) in place of the Java classes, and test each method as you add it.
An animated walkthrough of what a hash table with separate chaining looks like internally: an array of buckets where each bucket holds a linked chain of entries. It introduces the design of the structure before any code is written, including how keys are placed and how collisions are absorbed into chains.
This is the right starting point for Setting Up the HashTable Class, since it establishes the mental model of the bucket array and chains that your JavaScript class will mirror.
The follow-up to Part 1, moving from animation to actual implementation. It walks through coding the hash table class, its internal storage, and the supporting pieces needed to make separate chaining work in code.
Seeing the structure translated into working code bridges the gap between the diagram and your own class definition, hash function, and bucket array in JavaScript.
A focused treatment of the insertion operation: how a key-value pair is placed into the table under separate chaining. It covers computing the index from the key, handling the case where the bucket is already occupied, and appending to or updating within the existing chain.
Insertion is the method where hashing and collision handling meet, so this directly supports Writing the Hash Function and Implementing the set Method with Chaining — including the update-versus-append decision students commonly get wrong.
Together these videos carry the heaviest weight for MO4: they model the full path from structural design to coded set logic with separate chaining, giving you a reference implementation to adapt into a JavaScript class with set, get, remove, and keys. The index-computation discussion reinforces MO1 by showing how a key is deterministically reduced to a valid array position, while the chain-handling in the insertion video supports MO2 and MO3 by making visible what grows when collisions occur and why longer chains push operations away from constant time. Use the videos for the design logic, then write, run, and systematically test your own JavaScript version to complete the outcome.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.