Big-O Complexity Flashcards
34 cards · EN → EN · Coding
Master algorithm time and space complexity analysis. Covers all major complexity classes, common algorithm complexities, data structure operation costs, and key rules for calculating Big-O. Essential for coding interviews and writing efficient software.
This page covers Big-O Complexity: 34 flashcards in the coding category. Cards are oriented around the EN → EN language pair, so each prompt trains recognition in the direction you actually need. Difficulty is tagged intermediate, so you can expect a intermediate-friendly progression rather than a random dump of trivia.
FSRS keeps interview and engineering flashcards efficient: stable HTTP or complexity facts drift further out, while shaky ones return sooner. That is how you keep all 34 prompts in "Big-O Complexity" cold-start ready without grinding the whole list every night.
Scroll the first twenty cards for a feel of the fronts and backs, then download the app or open the web signup flow to keep studying with adaptive intervals.
Card preview
First 20 cards from this deck (front / back).
| # | Front | Back |
|---|---|---|
| 1 | What is Big-O notation? | A mathematical notation describing the upper bound (worst-case) growth rate of an algorithm's time or space requirements as input size n grows toward infinity. It ignores constants and low-order terms. |
| 2 | O(1) — Constant Time | Execution time does NOT grow with input size. Single operation regardless of n. The best possible complexity. |
| 3 | O(log n) — Logarithmic Time | Time grows proportional to log₂(n). Each step halves (or divides) the problem. Doubling input adds only ONE more step. Excellent for large datasets. |
| 4 | O(n) — Linear Time | Time grows directly proportional to input size. If n doubles, time doubles. Typically means visiting each element once. |
| 5 | O(n log n) — Linearithmic Time | Slightly worse than linear. Common in divide-and-conquer sorting algorithms. Often considered the theoretical minimum for comparison-based sorting. |
| 6 | O(n²) — Quadratic Time | Time grows as the square of input size. Doubling n quadruples the time. Usually appears with nested loops over the same data. |
| 7 | O(n³) — Cubic Time | Time grows as the cube of input size. Typically three nested loops. Practical only for very small inputs. |
| 8 | O(2ⁿ) — Exponential Time | Time doubles with each additional input element. Quickly becomes infeasible even for moderate n. Often arises in brute-force recursive algorithms. |
| 9 | O(n!) — Factorial Time | Time grows factorially with input size. Even n=20 produces 2.4 quintillion operations. Only feasible for tiny inputs (n < ~12). |
| 10 | Big-O Complexity Order (best to worst) | O(1) < O(log n) < O(√n) < O(n) < O(n log n) < O(n²) < O(n³) < O(2ⁿ) < O(n!) |
| 11 | Rule: Drop Constants | Big-O ignores constant multipliers. O(2n), O(100n), and O(0.001n) are all O(n). Constants don't affect the growth class. |
| 12 | Rule: Drop Non-Dominant Terms | Keep only the fastest-growing term. O(n² + n) = O(n²). O(2ⁿ + n³) = O(2ⁿ). |
| 13 | Rule: Different Variables for Different Inputs | If an algorithm processes two independent inputs of sizes n and m, the complexity is O(n + m) or O(n × m), NOT O(n²). |
| 14 | Space Complexity | Amount of extra memory an algorithm uses relative to input size n. Measured the same way as time complexity. Input itself doesn't count (only auxiliary space). |
| 15 | Array — Access | O(1) — Direct index access |
| 16 | Array — Search (unsorted) | O(n) — Must check every element in worst case |
| 17 | Array — Insert/Delete (end) | O(1) amortized for dynamic arrays (e.g., push/pop at end) |
| 18 | Array — Insert/Delete (middle) | O(n) — Must shift elements to fill the gap or make room |
| 19 | Hash Map — Lookup / Insert / Delete | O(1) average case. O(n) worst case (all keys collide — extremely rare with good hash functions). |
| 20 | Binary Search Tree (balanced) — Search/Insert/Delete | O(log n) for balanced BST (AVL, Red-Black). O(n) worst case for degenerate (unbalanced) BST. |
How to study with FSRS
Rate each card Honestly after you recall. FSRS uses that rating to set the next interval—hard cards return sooner, easy ones wait longer. Keep sessions short and daily rather than cramming the full deck.
Study this deck in Neurako
Clone-style study on web and mobile with FSRS from day one. Prefer Anki? Convert decks with our free CSV and APKG tools.
Frequently asked questions
Are these Big-O Complexity flashcards free?
Yes. You can preview cards here and start studying free in Neurako on web or mobile. Pro adds higher AI limits and advanced FSRS optimizer controls.
Can I import Big-O Complexity cards into Anki?
Export or convert with our free csv-to-anki and apkg-to-csv tools on tools.neurako.com, then study in Anki or Neurako—whichever you prefer.
How many Big-O Complexity cards are in this deck?
This deck includes 34 cards. The preview on this page shows the first 20 so you can judge style and difficulty before cloning.
How is Neurako different from Quizlet for Big-O Complexity?
Neurako schedules reviews with FSRS adaptive spaced repetition. Quizlet is stronger for quick social sets and games; Neurako is built for long-term retention.
Related flashcard decks
HTTP Status Codes Flashcards
All essential HTTP response status codes grouped by class (1xx–5xx), with meanings and real-world context. Based on IETF
ExploreAmino Acids Flashcards
All 20 standard amino acids with one-letter codes, three-letter codes, and side-chain chemical properties. Built for bio
ExploreHuman Anatomy Flashcards
About fifty major bones and bony landmarks of the human skeleton with their body region or location. Anatomical naming f
ExploreArabic Flashcards
100 of the most common Modern Standard Arabic (MSA / Fusha) words. MSA is used in formal communication, news, and educat
ExploreStart your atelier of knowledge today.
Download on iOS or Android, or keep studying in the browser—the same decks, FSRS reviews, and quiz practice, with clear Free vs Pro limits.