Overview
The book consists of 11 chapters, though the first one is more like an introduction (it’s even titled "Getting Acquainted with Algorithms"), and the last chapter covers what you can (and ideally should) study next, as well as topics the book doesn’t fully explore (such as MapReduce, Bloom filters, SHA, and more). So, what does this book cover? Let’s take a quick look.
First, the book discusses algorithm complexity and the so-called "Big O" notation. And believe me, the vast majority of programming courses teach highly specialized skills but rarely touch on algorithm runtime complexity or code optimization.
As for the topics covered, I’ll briefly go over them in this paragraph.
The book starts with a chapter on arrays and linked lists, explaining how to work with them (in terms of sorting and searching). It lists the advantages and disadvantages of lists (from the perspective of read/write speed and data storage).
Next is a short chapter on recursion, covering the call stack and its mechanics.
After that, the book dives into quicksort (using the "divide and conquer" approach). To reinforce the understanding of "divide and conquer," the author provides three examples. The pivot element is discussed, and performance comparisons of different sorting methods (including those from earlier chapters) are illustrated with graphs.
The following section introduces a new data type—or rather, a fundamental structure—hash tables. It outlines scenarios where they should be used (e.g., eliminating duplicates, caching, modeling relationships between objects). Collision cases are also examined and explained.
Then, the book introduces graphs as a data structure. No, it doesn’t cover all the topics I studied in "Mathematical Modeling," but at least it touches on the basics: what a graph is, its purpose, applications, and directed vs. undirected graphs. And since graphs are all about "paths," the algorithms covered include breadth-first search and finding the shortest path. This chapter also mentions queues and revisits stacks, explaining FIFO and LIFO—though, in my opinion, this should’ve been covered earlier. By the way, two full chapters are dedicated to graphs. If the first one deals with finding the shortest path in an unweighted graph, the second focuses on weighted graphs using Dijkstra’s algorithm. Again, multiple examples are provided: first abstract, then in code. The Bellman-Ford algorithm (for graphs with negative-weight edges) isn’t covered and is left for self-study.
Toward the end, the book tackles less common (in everyday programming) problems and algorithms. For example, it discusses greedy algorithms, approaches to "impossible" problems with no fast algorithmic solution (NP-complete problems), dynamic programming (breaking complex problems into subproblems), and the k-nearest neighbors algorithm used in machine learning.
Features
The book includes illustrations that help visualize and supplement the material. Each chapter also contains 5–7 practical questions. These are mostly conceptual (though some involve code), and the answers are provided at the end for self-checking. Every chapter concludes with a "cheat sheet"—a summary in 4–5 sentences.
The book is about 300 pages long, and the chapters are concise, so there’s a good chance anyone who starts it will finish it. It’s an easy and quick read.
Conclusion
A great book for those who entered programming without a technical background. It explains various sorting and search methods (binary search, depth-first and breadth-first search) in simple terms. It covers the crucial topic of algorithm complexity ("Big O"). There’s even material on graphs, shortest-path algorithms, k-nearest neighbors, and other fundamental topics every programmer should know at least at a basic level.
