What a Structure Promises
A data structure is a concrete way of organizing data in memory; an abstract data type (ADT) is the behavior that organization provides, described independently of how it is built. The distinction is the foundation of this whole unit: the ADT is the interface (a set of operations and their promised behavior), and a data structure is one implementation of it.
For example, a List ADT promises operations like get(i), add(x), remove(i), and size(). It can be implemented by a contiguous array or by a chain of linked nodes — two structures with very different performance, both honoring the same List interface. Because callers depend on the interface, not the implementation, you can swap one for the other to change performance without changing the code that uses the list.
Choosing a data structure is really about which operations you need to be fast. Each implementation makes some operations cheap and others expensive, so there is no universally "best" structure — only the best fit for a given pattern of use. This unit studies the standard ADTs (list, stack, queue, tree, dictionary, priority queue, graph) and the structures that implement them, always asking: which operations does this make fast, and at what cost?
Common pitfall: conflating the ADT with a particular implementation — thinking "a list is an array." A list is an interface; an array is one way to implement it (a linked structure is another). Keeping the interface and implementation separate is what lets you reason about behavior first and performance second.