Learn Data Structures with 95 Flashcards: From Arrays to Tries
Arrays, hash tables, BSTs, tries and graphs: what the 95-card Data Structures deck on Flip It covers, the duplicates to prune and the complexities to add.
Studying. But it's also a video game. 🎮
Flashcards, quizzes and games that make you actually remember.
Posted by
FLIP IT TeamRelated reading
Master Dynamic Programming with 30 Flashcards: Memoization, Knapsack, LCS and Bitmask DP
Master dynamic programming with deck AI3432: 30 flashcards on memoization, tabulation, knapsack, LCS, LIS, edit distance, Kadane, bitmask and digit DP.
Study Guide: Software Testing in 40 Flashcards — Unit, Integration and 30 More Test Types
Learn software testing with 40 flashcards: unit vs integration, the test pyramid, smoke vs sanity, load vs stress, code coverage, mutation testing and TDD.
Learn Big O Notation in German: 44 Flashcards on Landau-Notation, Schranken and Sorting Costs
German edition of the Big O flashcard deck: obere, untere and scharfe Schranke, Mergesort, Knoten and Kanten, plus three cards to fix before you study.
Interviews rarely ask you to implement a red-black tree. They ask why you reached for a hash table instead of an array, and what that costs — a vocabulary problem before it is a coding problem, and therefore ideal flashcard material. Deck DQ0342 — Data Structures, 95 cards — on Flip It covers the standard syllabus in short question-answer form.
Study this deck: Data Structures
1 / 10Data structure
Tap the card for the answer · swipe right if you knew it, left if not
What the 95 cards cover
Linear structures: arrays, contiguous memory allocation, random access, dynamic arrays and amortized O(1) insertion, singly/doubly/circular linked lists, records and their fields, sets, multisets (bags), dictionaries and associative arrays.
Abstract data types: stack (push/pop, LIFO), queue (enqueue/dequeue, FIFO), deque, priority queue and the heap that implements it, opaque data types, modular programming, classes as the OOP abstraction mechanism.
Hashing: hash functions, key-value lookup, average O(1) access, collisions, chaining, open addressing.
Trees: root, leaves, height, depth, binary trees, binary search trees, AVL trees, B-trees (and why relational databases index with them), min-heaps and max-heaps, tries for autocomplete and spell-checking, self-balancing, plus in-order, pre-order and post-order traversal.
Graphs: directed and undirected, weighted, cycles, DAGs, spanning trees, adjacency matrix vs adjacency list, BFS and DFS.
Cross-cutting: pointers, space vs time complexity, Big O with O(1), O(log n) and O(n), persistent, succinct and concurrent data structures, POD types, spatial locality and cache-friendliness, the C++ STL and the Java Collections Framework.
Eight cards, verbatim
| Front | Back |
|---|---|
| How does an ADT relate to a data structure? | The ADT defines the logical form; the data structure implements the physical form |
| Principal advantage of a linked list over an array | Values can be efficiently inserted and removed without relocating the rest of the list |
| Two techniques to handle hash collisions | Chaining and open addressing |
| Binary search tree (BST) | A binary tree where left subtree values < node value < right subtree values |
| Trie (prefix tree) | A tree where each node represents a character, used for efficient string retrieval |
| Amortized cost of dynamic array insertion | O(1) - constant time on average |
| Cache-friendly data structure | A structure that exploits spatial locality for better cache performance (e.g., arrays) |
| Succinct data structure | A data structure using space close to the information-theoretic lower bound |
Answer every definition card with a complexity
Only five cards state a cost: array access O(1), hash table access O(1) average, linked list traversal O(n), BST search O(log n) average, dynamic array insertion amortized O(1). Every other structure is defined without one. Use the gap: when Deque or Trie comes up, say the definition and the insert/search cost before flipping. The deck grades the first half, the interview the second.
Two costs are worth adding as your own cards, because they are the standard follow-up questions: a hash table degrades to O(n) when every key collides, and so does an unbalanced BST — which is the entire reason AVL and B-trees exist. The deck introduces all three structures without ever connecting them to that failure case.
Prune the duplicates first
Four pairs teach the same fact twice. Leaves in a tree and Leaf node have identical answers; Stack already says LIFO before a separate card asks which principle a stack follows, same for Queue and FIFO; Hash table reappears as What data structure provides efficient key-value lookups?. Suspend one of each, or your review count looks healthier than your knowledge. Expect bare noun-phrase fronts too (Advantage of arrays, Graphs used to model) — they lost their question stem in generation; read them as fill-in-the-blank prompts.
Related reading
The graph cards stop at BFS and DFS; How to Memorize Sorting, Searching and Graph Algorithms picks up at Dijkstra, Prim and Kruskal. Structures first, algorithms second.
Log in to Flip It, find DQ0342 in the library, and start with the trees block.
Ready to learn faster? 🚀
Join FLIP IT for free and turn studying into a game.