Cracking the Coding Interview by Gayle Laakmann McDowell is still the best-known interview book, and its sixth edition, published in 2015, carries the subtitle '189 Programming Questions and Solutions'. Those 189 problems are spread over 17 chapters, and not all of them match what interviews ask today. This page lists the chapters with their question counts, says which still matter, maps book problems to their closest LeetCode counterparts so you can pair the book with a list such as the NeetCode 150 roadmap or Blind 75 guide, and gives a study order that builds patterns.
What is in the book
We checked the sixth edition's table of contents, published on the book's own site, on November 12, 2026.
- Parts I to VIII, before the questions: the interview process, how companies such as Microsoft, Amazon, Google, Apple, Facebook and Palantir ran interviews at the time, special situations, behavioral preparation, Big O, and technical questions.
- Five problem-solving techniques in the technical-questions part: look for bottlenecks, unnecessary work and duplicated work (BUD), do it yourself, simplify and generalize, base case and build, and data structure brainstorm, plus the idea of a best conceivable runtime.
- Part IX, the 189 questions, in four groups: data structures, concepts and algorithms, knowledge-based, and additional review problems.
- After the questions: full solutions, advanced topics such as topological sort, Dijkstra's algorithm, AVL and red-black trees, a small code library, and a hints section with hints for every question.
- Solutions are written in Java. The book's public solutions repository also has folders for more than a dozen other languages.
The 17 chapters and how they hold up
| Chapter | Questions | Today's relevance (our read) |
|---|---|---|
| 1. Arrays and Strings | 9 | Core; still common |
| 2. Linked Lists | 8 | Core |
| 3. Stacks and Queues | 6 | Core |
| 4. Trees and Graphs | 12 | Core |
| 5. Bit Manipulation | 8 | Occasional |
| 6. Math and Logic Puzzles | 10 | Rare as stand-alone puzzles |
| 7. Object-Oriented Design | 12 | Useful for low-level design rounds |
| 8. Recursion and Dynamic Programming | 14 | Core |
| 9. System Design and Scalability | 8 | A starting point only |
| 10. Sorting and Searching | 11 | Core |
| 11. Testing | 6 | Mostly for test and quality roles |
| 12. C and C++ | 11 | Language rounds |
| 13. Java | 8 | Language rounds |
| 14. Databases | 7 | SQL screens |
| 15. Threads and Locks | 7 | Concurrency rounds at some companies |
| 16. Moderate | 26 | Mixed practice |
| 17. Hard | 26 | Mixed practice, many classic hard problems |
The data structures chapters, recursion and dynamic programming, sorting and searching, and the two review chapters hold 112 of the 189 questions and are where the book still pays off. The knowledge-based chapters, C and C++, Java, databases and threads, matter only if your role tests them.
Book problems and their LeetCode counterparts
Many book problems have a close LeetCode version, which lets you test your solution against a judge:
| Chapter | Book problems | Closest LeetCode problems |
|---|---|---|
| 1. Arrays and Strings | Check Permutation, Rotate Matrix, Zero Matrix | Valid Anagram, Rotate Image, Set Matrix Zeroes |
| 2. Linked Lists | Partition, Sum Lists, Palindrome, Intersection, Loop Detection | Partition List, Add Two Numbers, Palindrome Linked List, Intersection of Two Linked Lists, Linked List Cycle II |
| 3. Stacks and Queues | Stack Min, Queue via Stacks | Min Stack, Implement Queue using Stacks |
| 4. Trees and Graphs | Minimal Tree, List of Depths, Check Balanced, Validate BST, Build Order, First Common Ancestor, Check Subtree, Paths with Sum | Convert Sorted Array to BST, Level Order Traversal, Balanced Binary Tree, Validate BST, Course Schedule II, Lowest Common Ancestor of a Binary Tree, Subtree of Another Tree, Path Sum III |
| 8. Recursion and DP | Triple Step, Power Set, Permutations, Parens, Paint Fill, Coins, Eight Queens | Climbing Stairs (a three-step variant), Subsets, Permutations I and II, Generate Parentheses, Flood Fill, Coin Change II, N-Queens |
| 10. Sorting and Searching | Group Anagrams, Search in Rotated Array, Sorted Matrix Search | Group Anagrams, Search in Rotated Sorted Array, Search a 2D Matrix II |
| 16. Moderate | Factorial Zeros, Sub Sort, Contiguous Sequence, LRU Cache, Calculator | Factorial Trailing Zeroes, Shortest Unsorted Continuous Subarray, Maximum Subarray, LRU Cache, Basic Calculator II |
| 17. Hard | Add Without Plus, Majority Element, The Masseuse, Continuous Median, Volume of Histogram, Word Transformer | Sum of Two Integers, Majority Element, House Robber, Find Median from Data Stream, Trapping Rain Water, Word Ladder |
What the book misses for today's interviews
- Named patterns: the book teaches by data structure, not by pattern. Sliding windows, monotonic stacks, prefix sums with hash maps and binary search on the answer, all common now, are only implicit. Our LeetCode patterns guide fills that gap.
- Volume of medium problems: 189 questions, many conceptual, is fewer than most candidates now practise; a 75- to 150-problem LeetCode list adds the repetition.
- System design depth: chapter 9 has eight questions, enough to learn the vocabulary but not to pass a senior design round. See what a system design interview is.
- Company processes: the 'behind the scenes' chapter describes how large companies interviewed around 2015; online assessments, AI-led screens and today's loops differ, so check current guides for each company.
- Brainteasers: chapter 6's logic puzzles are rarely asked as stand-alone questions now, though the math basics still help.
A study order that pairs the book with a list
- Week 1: read Big O and the technical-questions chapter, then chapter 1 (9 questions) and the arrays and hashing problems of your list.
- Week 2: chapters 2 and 3 (14 questions) with the list's linked-list and stack problems.
- Week 3: chapter 4 (12 questions) with the list's trees, tries and graphs.
- Week 4: chapter 10 (11 questions) and chapter 5 (8 questions) with binary search and bit problems.
- Weeks 5 and 6: chapter 8 (14 questions) with the list's backtracking and dynamic programming.
- Weeks 7 and 8: chapters 16 and 17 (52 questions) as mixed, unlabelled practice, timed at 30 minutes each.
- Any time: chapter 7 if you expect object-oriented design, and chapters 12 to 15 only if your role tests them.
Use the book's hints section before reading a full solution: it gives one or two hints per question, which is closer to how an interviewer helps.
Turning a list into interview skill
Any list only helps if the practice transfers to problems you have not seen. These habits make the difference:
- Time-box every attempt: about 25 minutes for a medium before you read a solution.
- Keep a log with one line per problem: the pattern, the key idea and the complexity.
- Redo failed problems after three days, a week and three weeks, without looking at your old code.
- Explain your approach out loud before and while you code, as you would to an interviewer.
- In the last two weeks, switch to unseen problems without topic labels.
The patterns most lists are built on are explained in array and string patterns and tree, graph and recursion patterns.
Where CoPilot Interview fits
Finishing a list is not the same as passing an interview: interviewers score how you explain your approach, your trade-offs and your complexity out loud. CoPilot Interview is an AI interview assistant; its free AI mock interview asks coding questions, listens to your spoken explanation and scores it out of ten with a model answer, which is the part a problem list cannot train. The free plan gives 15 minutes a day of live help in sessions of up to 15 minutes, with AI mock interviews included. Online assessments and live coding rounds usually forbid outside help, so practice now and follow your employer's rules on the day.
Disclosure: CoPilot Interview is our product, so weigh what we say about it accordingly.
Frequently asked questions
How many problems are in Cracking the Coding Interview?
The sixth edition has 189 programming questions in 17 chapters, with solutions and hints for each.
Is Cracking the Coding Interview still worth reading?
Yes for its approach to problem solving, Big O and the core data structure chapters. Pair it with a modern LeetCode list for pattern practice and volume, and use newer sources for system design and company processes.
Which chapters of Cracking the Coding Interview matter most?
Chapters 1 to 4, 8 and 10, plus the moderate and hard review chapters, which together hold 112 of the 189 questions.
Can I practise the book's problems on LeetCode?
Many have close LeetCode counterparts, such as Stack Min and Min Stack or Volume of Histogram and Trapping Rain Water. Solving the LeetCode version lets a judge test your code.
Practice this interview before the real one
The AI mock interview builds questions from your resume and the job description, reads them aloud and scores each spoken answer out of 10. Included on the free plan.
Start a mock interview