Storage formats that decide how fast your program can find, add, and remove data.
A data structure is really just a storage format, a way of organizing data so you can store it, find it, and update it quickly. Every data structure gives up something to make the operations you care about a lot faster for your use-case. If you choose the right data structure for your scenario, you can often trade some memory for a much faster solution.
I've curated these data structures in this order because I believe the order matters. Every data structure on this page exists to fix something that the others couldn't really do. In other words, they have their pros and cons. If you're new to this, try starting at the top and working your way down. It'll help you understand what the differences are and why they are necessary.
Think of these as the "OG" data structures. During my time at FAANG, I saw these data structures in production-level code almost 99.99% of the time. As a matter of fact, I have never seen a linked list in production. These data structures are the foundation of all other data structures and should be studied the most for mastery.
Reading element 50,000 takes exactly as long as reading element 0, because position is computed, not searched.
Insert at the front without shifting a single element. The catch is that reaching anything means walking the chain.
Pull one value out of a million in a single step. The key itself tells you where to look.
How printers and web servers decide what to handle next. Whatever has waited longest goes first.
These are my personal favorite data structures because they enable you to work with some of the most badass algorithms in all of technology. These data structures don't actually "exist." You build them using the ones from earlier. These data structures aren't difficult to build or understand, but the algorithms that we use with them can get pretty messy. I hope you enjoy these as much as I do.
Folders inside folders, replies under replies. When data nests, a flat list stops working and a tree takes over.
Almost nothing in a heap is sorted, yet the smallest item is always on top. The sloppiness is what makes it fast.
Road maps and social networks are the same structure underneath: things, and the connections between them.
An image, a maze, a chessboard. Anything laid out in rows and columns is already a matrix.
These guys have their own fancy section because these data structures are extremely niche and were built for a very specific reason. I could technically put them under trees or graphs, but they deserve their own space. It's possible to derive them by yourself during an interview, but you are better off studying them and understanding what's actually possible with data structures.
Find every word starting with "ca" without scanning the whole dictionary. This is the tree autocomplete is built on.
It answers one question fast: after a million merges, are these two items in the same group?
Sum any slice of an array in about 20 steps, even while the values underneath keep changing.