book

Head First Algorithms and Data Structures

by Eric Freeman, Elisabeth Robson

September 2026

Beginner to intermediate

500 pages

12h 27m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Brief Table of Contents (Not Yet Final)
1. Comparing Algorithms: A Recipe for Speed
Welcome to Micro-StorageLooking at the codeLet’s put the code to the testThe second implementationHow binary search worksWhat is an algorithm, anyway?We need more precision than a recipeBeing more preciseIntroducing Time ComplexityLooking at our two functions for Micro-StorageGraphing Time ComplexityLooking at the binary search functionGraphing logarithmic timeYour Great Algorithm Adventure BeginsAlgorithms crossAlgorithms cross Solution
2. The Universal Language of Algorithm Performance: Big O
Say Hello to Big OHow do I say O(n) again?Constant timeIntroducing quadratic timeUnderstanding quadratic timeGraphing quadratic timeDid someone say pizza?Let’s write the code to compute the combo toppingsGoing exponentialHow long?Just when you thought it couldn’t get worse…The final graphWelcome to Algorithm Land!Algorithms crossAlgorithms cross Solution
3. Algorithms and Data Structures: The Secret of a Great Performance
Let’s talk about data structuresMeet arrays, again, for the first timeUnderstanding static arraysAccessing and storing items in a static array is fastAppending a new itemsTime complexity of static array operationsFireside ChatsWhat about dynamic arrays?Appending new itemsWhat happens when the extra space runs out?Arrays in the real worldTime complexity of dynamic array operationsIntroducing linked listsHow to operate on linked listsUpdateInsertDeleteSearchChecking in on time complexities of a linked listThe doubly-linked listInserting into doubly-linked listsInsertInserting at the end of a doubly-linked listWhat about the middle?Okay, what about the time complexityDecisions, decisions...Reading by positionAdding to and removing from the frontLots of in-place inserts and deletesAdding to and removing from the endBringing it all togetherChecking in on Micro-StorageAlgorithms crossAlgorithms cross Solution
4. Thinking Recursively: Recursion
Let’s get some ice creamGetting more formalHow recursion worksImplementing factorialUsing recursion to implement factorialAlgorithm MagnetsFibonacci numbersMapping out our function callsUnderstanding the call stackBack to our Fibonacci problemUnderstanding memoizationAlgorithm MagnetsWhat is the Big O of Fibonacci?Algorithms crossAlgorithm Magnets SolutionAlgorithm Magnets SolutionAlgorithms cross Solution
5. Sorting: Sorting Things Out
How to sort an arrayStart at the beginning and compareOur second passOn to pass threeMeet Bubble SortInsertion SortImplementing insertion sortFireside ChatsIntroducing merge sortThe merge sort code: the splitThe merge sort code: the mergeThe time complexity of merge sortWhat about space complexity?A quicker way to sort?Meet quicksort: more divide and conquerAn example of quicksortImplementing quicksortComparing merge sort and quicksortA brief look at stabilityFinal Big O comparison of the sorting algorithmsAlgorithms crossAlgorithms cross Solution
6. Serious data Structures: Hash Tables, Stacks, and Queues
Can Micro-Storage be saved?Meet the hash tableHow a hash table worksHow collisions workThe secret of the hash table; or, why is it so fast?Making better keys for booksTime and space complexity of hash table operationsMeanwhile, back at Micro-StorageFrom ‘Find Anything Fast’ to ‘Last In, First Out’Using a stack in practiceThe time complexity of stack operationsManaging web histories with stacksHow our browser history works with stacksThe browser codeQueuesUsing a queue in practiceThe time complexity of queue operationsBuilding a queueThe Head First taxiAlgorithms crossAlgorithms cross Solution
7. Graphs and Graph Traversal: Understanding Graphs
It’s all about relationshipsWhat is a graph?What is a path?ConnectivityIntroducing directionAdding some weightBi-directional edges and weightsExerciseCycling with cyclesHow to store a graphThe adjacency listMoving around the graphFinding neighbors with codeFinding the cost of a routeAnother visit to Algorithm LandHow to represent Algorithm LandExploring Algorithm Land with Breadth First TraversalHow breadth-first traversal worksImplementing breadth-first traversalFinding the shortest pathExploring Algorithm Land Depth-FirstHow depth-first traversal worksImplementing depth-first traversalDepth-first traversal is naturally recursiveFireside ChatsRepresenting a graph with an adjacency matrixQuickly exiting Algorithm LandBreadth-first search with an adjacency matrixThe Big O of graph algorithms: vertices and edgesHow the data structure impacts the complexityAlgorithms crossExercise SolutionAlgorithms cross Solution
8. Greedy Algorithms: Being Greedy
What does it mean to be greedy?How greedy strategies workGreedy algorithms find a solution, not necessarily the best one.Meanwhile, back in Algorithm Land it’s getting crowded!Using BFS to find the shortest pathWhat went wrong?The secret to Dijkstra’s algorithmWhat’s a priority queue?Remembering breadth-first searchMeet Dijkstra’s algorithmLet’s trace through DijkstrasWhat is the complexity of Dijkstra?Computing the time and space complexityWhat about space complexity?Understanding Trees & HeapsHeapsCreating heapsHow heap ordering worksGreedy is everywhereTake a breakA greedy challenge: grab the dragon’s lootWhy brute force blows up in your faceFinding a fast and greedy solutionImplementing the knapsack algorithmWhat happened?How much faster is the greedy approach with knapsack?Let’s compare that to brute forceAlgorithms crossAlgorithms cross Solution
9. Dynamic Programming: Been There, Stored That
When greedy failsWhy Did Greedy Fail?Discovering overlapping subproblemsMeet Dynamic ProgrammingAn alternative to memoizationBottom-up dynamic programmingImplementing bottom-up FibonacciBack to the coin change problemThe base caseAmount 1Amounts 2-6Amount 7: Our first real choiceAmount 8Amount 9Amount 10: The 10 token enters the gameAmount 11Amount 12Amount 13Amount 14How to use the dynamic programming tableWhat change did we get?Coding the coin solutionBig O analysisA new problem for dynamic programmingSame pattern, different problemKnapsack has overlapping subproblems tooOverlapping subproblemsBack to the Dragon’s LairIdentifying the subproblemBuilding the tableAdding goldAdding silver gobletsAdding silver goblets: Do we or don’t we?What if both items fit?Filling in the rest of the goblet rowAdding ancient scrollsAdding ancient scrolls, continuedBacktracking to find which items we tookCoding the dynamic programming Knapsack solutionBig O of dynamic programming knapsackWhat about space complexity?Fireside ChatsGet your own dynamic programming problemThe bottom lineFeeling Powerful?About that...Then it gets stranger...

10. The Limits of Algorithms: The Edge of the Computable Universe
Is there really no problem too hard?Meet P and NPWelcome to the Escape RoomThe StatuesThe Rune TabletThe Broken KeyThe PatternFireside ChatsThe hardest problems in NP have a nameBrace yourself.What kind of problems are not computable?The Halting ProblemNow let’s try to write some code to detect a haltHere’s where it gets weirdThat’s not a bug, it’s a proofWhen problems are undecidableSo where does that leave us?Here’s the thingHitting the Wall: A Field GuideWhen “Good Enough” is GreatThe Nearest Neighbor AlgorithmAlgorithms cross
A. Leftovers The Top Ten Topics (We Didn’t Cover)
#1 Tries (Prefix Trees)Why they’re fastApplicationsTradeoffs#2 The LRU CacheWhat is the problem?Combining them#3 Self-Balancing TreesRotationsTwo flavors of treesWhy you care#4 Parallel and Distributed AlgorithmsParallel or distributed?Take-home ideas#5 String AlgorithmsThe basic problemFour common string tasksA simple exampleAn Improvement#6 Approximation AlgorithmsThe Core IdeaA Simple PatternWhere you’ll find approximation algorithmsThe takeawayA Familiar Example#7 Machine LearningThe Big Ideas#8 External Memory AlgorithmsThe Core InsightKey Concepts dealing with external memory#9 Randomized AlgorithmsTwo Flavors You’ll EncounterA Different Kind of Analysis#10 Bit Manipulation
About the Authors

Content preview from Head First Algorithms and Data Structures

Brief Table of Contents (Not Yet Final)

Introduction (unavailable)

Chapter 1: Comparing Algorithms: A Recipe for Speed (available)

Chapter 2: The Universal Language of Algorithm Performance: Big O (available)

Chapter 3: Algorithms and Data Structures: The Secret of a Great Performance (available)

Chapter 4: Thinking Recursively: Recursion (available)

Chapter 5: Sorting Things Out: Sorting (available)

Chapter 6: Serious Data Structures: Hash Tables, Stacks, and Queues (available)

Chapter 7: Graphs and Graph Traversal: Understanding Graphs (available)

Chapter 8: Greedy Algorithms: Being Greedy (available)

Chapter 9: Dynamic Programming: Been There, Stored That (available)

Chapter 10: The Limits of Algorithms: The Edge of the Computable Universe (available)

Appendix: Leftovers: The Top Ten Topics (We Didn’t Cover) (available)

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Data Structures and Algorithms: The Complete Masterclass

Publisher Resources

ISBN: 9781098174071Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Head First Algorithms and Data Structures

by Eric Freeman, Elisabeth Robson

Brief Table of Contents (Not Yet Final)

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.