So far in COP3530 you have studied hash tables, trees, and graphs mostly as isolated topics: how each one is built, how it performs, and how to implement it. This topic shifts the perspective. Real systems rarely use a single structure in isolation — they layer and combine them. A database might use a hash index for point lookups, a B-tree for range queries, and a log-structured file for durable writes, all inside one engine. A blockchain combines a linked list, cryptographic hashing, and a Merkle tree. A social platform stores relationships as a graph while using hash tables to find a user's record in constant time.
The subtopics here build that layered view. Hash tables are the lookup foundation: constant-average-time access keyed by a value you compute rather than search for. Trees are hierarchical organizers: they keep data sorted, support ranges and prefixes, and summarize subtrees. Graphs model relationships that have no natural hierarchy — friendships, transactions, routes, dependencies. Composition is where these meet, and the conceptual framework is the habit of asking, for any system: what operations must be fast, what structure makes them fast, and what does that choice cost?
As you watch, resist the urge to just collect names of structures. For each one mentioned, ask three questions: what operation is it optimizing, what does it give up in exchange, and what would break if you swapped in a different structure? Jot down any case where two structures are used together — those composition examples are exactly what you will be asked to analyze and design later in this module.
A fast, animated tour of data structures that appear in systems people use daily, connecting each structure to a concrete application rather than to abstract operations. Based on its title and ByteByteGo's system-design focus, expect coverage of structures such as lists, hash tables, trees, heaps, and graphs, each paired with a real product or service where it does the work. The format is survey-style breadth rather than deep implementation detail.
It is the natural opening piece for this topic because it establishes the core framing — these structures are infrastructure, not just coursework — and touches hash tables, trees, and graphs within a single coherent narrative. ByteByteGo is a well-regarded system-design channel whose explanations are known for accuracy and clean visuals.
A focused lecture on what hashing actually means in a data structures context, working from a worked example rather than from formal definitions alone. Expect treatment of the hash function, mapping keys to table indices, and why this gives fast direct access compared to searching. As an introductory lecture in a numbered series, it is likely to set up collision handling as the follow-on problem.
This is the dedicated treatment for the Hash Tables as Lookup Foundations subtopic, and the example-driven approach is useful if your mental model of hashing is still fuzzy before the module moves on to cryptographic hash functions. Gate Smashers is a widely used exam-preparation channel known for short, methodical blackboard-style explanations.
A short overview of the data structures that database engines rely on internally, likely covering structures such as B-trees, LSM trees, hash indexes, and related variants, with attention to what each is good at. Being a database-focused piece, it should connect structural choices to operational behavior — reads versus writes, point lookups versus range scans. The emphasis is on why a given engine picks one structure over another.
This video is the clearest illustration of the Composition of Structures in Practice and Conceptual Framework subtopics: a database is a single system that deliberately combines several structures and accepts trade-offs for each. It gives you a concrete, analyzable example of the kind of structural reasoning you will later apply to a blockchain or digital currency platform.
These three videos supply the shared vocabulary and analytical habits the rest of the module depends on. The hashing lecture grounds the hash-function concept that MO1 extends into cryptographic hashing and Merkle trees, while the ByteByteGo survey reinforces trees and graphs as everyday system components — the starting point for the graph representation and traversal work in MO2 and MO3. The database video models MO4 directly: it shows how to look at a real system, name the structures inside it, and explain the trade-offs behind each choice. Together they build the composition mindset MO5 asks you to demonstrate, where a solution is assembled from several structures and each selection is justified against stated performance requirements rather than chosen by default.
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.