Introduction to Algorithms, fourth edition

The definitive reference on algorithms and data structures for students and practicing engineers

Build the algorithmic foundation every serious programmer needs, from sorting and graph search to NP-completeness and parallel computation.

C Charles E. Leiserson C Clifford Stein R Ronald L. Rivest T Thomas H. Cormen

Introduction to Algorithms is the standard reference that computer science programs and engineering teams reach for first. The fourth edition covers more than fifty algorithms in rigorous mathematical detail while staying grounded in practical application. Whether you are preparing for technical interviews, taking a graduate course, or filling gaps in your CS foundation, this book gives you the precise language, proofs, and intuition to reason about any algorithmic problem you encounter.

Buy on Amazon →

About this book

Introduction to Algorithms — CLRS to anyone who has worked through it — is the book that defined how a generation of programmers thinks about computation. The fourth edition, updated in 2022, reflects thirty years of refinement and adds coverage of topics such as online algorithms and machine-learning applications that previous editions predated.

The book treats algorithms as mathematical objects. Every major algorithm comes with a precise description, a correctness argument, and a worst-case analysis. That rigor is the point: when you understand why an algorithm works, not just how to call it, you can adapt it, combine it, and recognise when the tool you need does not yet exist in any library.

At 1,313 pages, this is a reference, not a weekend read. Use it cover-to-cover for a formal course, or use the self-contained chapters to go deep on one area at a time. The pseudocode is language-independent, so nothing becomes obsolete when your stack changes.

Part I covers the mathematical foundations: recurrences, summations, probability, and asymptotic notation — the vocabulary every later chapter depends on.
Part II covers the canonical sorting and order-statistics algorithms that appear in every technical interview and system design discussion.
Part III introduces data structures from hash tables to van Emde Boas trees.
Parts IV through VII cover advanced techniques: divide-and-conquer, dynamic programming, greedy algorithms, amortised analysis, and graph algorithms from BFS to maximum flow.
Part VIII addresses NP-completeness, approximation algorithms, and parallel and online algorithms added or expanded in this edition.

The exercises range from straightforward checks to open research-level problems. Worked examples throughout keep the abstraction grounded. If you need one algorithms book on your shelf — physical or digital — this is the one that will still answer your questions in ten years.

🎯 What you'll learn

Read and write asymptotic notation correctly and apply it to bound algorithm performance in best, average, and worst cases.
Prove algorithm correctness using loop invariants and mathematical induction.
Solve recurrences with the master theorem and related techniques.
Implement and analyse the full family of sorting algorithms, from insertion sort through radix sort.
Choose and apply the right data structure — heaps, balanced BSTs, hash tables, disjoint sets — for a given problem.
Design algorithms using divide-and-conquer, dynamic programming, and greedy strategies.
Analyse graph algorithms including shortest paths, minimum spanning trees, and maximum flow.
Identify NP-complete problems and reason about approximation strategies when exact solutions are intractable.

👤 Who is this book for?

Computer science students taking a formal algorithms or data structures course who need a textbook that matches graduate-level rigor.
Software engineers preparing for technical interviews at companies where algorithm questions go beyond LeetCode basics.
Self-taught developers who skipped a formal CS education and want to close the gaps in their understanding of complexity and correctness.
Researchers and data scientists who need precise algorithmic definitions rather than hand-wavy blog-post explanations.
Engineering leads and architects who need to reason accurately about the performance characteristics of the systems they design.

01

Foundations: Mathematics and Asymptotic Notation

Establishes the mathematical vocabulary the rest of the book depends on, including asymptotic notation, summations, recurrences, and basic probability. You will learn to express and compare algorithm costs in a language that is independent of hardware or language choice.
02

Sorting and Order Statistics

Covers insertion sort, merge sort, heapsort, quicksort, and linear-time sorting algorithms including counting sort and radix sort. You will analyse each algorithm's correctness and complexity and understand when each is the right choice.
03

Data Structures

Introduces stacks, queues, linked lists, hash tables, binary search trees, and red-black trees. You will learn the operations each structure supports, its performance guarantees, and the implementation details that make those guarantees hold.
04

Advanced Data Structures

Extends basic structures to augmented BSTs, interval trees, van Emde Boas trees, and disjoint-set forests. You will learn how to augment a data structure to answer new queries without losing existing performance bounds.
05

Algorithm Design Techniques

Covers divide-and-conquer, dynamic programming, and greedy algorithms as general design paradigms. You will work through canonical examples — matrix-chain multiplication, Huffman codes, activity selection — and learn the structural conditions that make each paradigm applicable.
06

Graph Algorithms

Develops breadth-first search, depth-first search, topological sort, strongly connected components, minimum spanning trees, and single-source shortest paths. You will trace each algorithm on concrete graphs and prove correctness using the properties of the graph structures involved.
07

Selected Topics: Flow, Linear Programming, and Polynomials

Covers maximum flow, bipartite matching, linear programming basics, and polynomial and FFT algorithms. You will see how flow networks model real scheduling and matching problems and how FFT enables fast polynomial multiplication.
08

NP-Completeness and Computational Intractability

Defines the complexity classes P and NP, presents polynomial-time reductions, and proves several canonical problems NP-complete. You will be able to recognise NP-hard problems in practice and argue why no efficient exact algorithm is likely to exist.
09

Approximation Algorithms and Advanced Topics

Presents approximation algorithms for NP-hard problems, including vertex cover, the traveling-salesman problem, and set cover. The chapter also introduces parallel and online algorithms added or expanded in the fourth edition, giving you tools for problems where exact or offline solutions are unavailable.

Frequently asked questions

What mathematical background do I need before reading this book?

Comfort with discrete mathematics — induction, basic combinatorics, and elementary probability — is enough to start. The first part of the book covers the specific mathematical tools used throughout, so you can fill gaps as you go.

Is this book suitable for self-study, or is it mainly a classroom textbook?

It works well for self-study. The chapters are largely self-contained, and the exercises at the end of each section let you test your understanding. Working through the problems rather than just reading the text is essential.

Does the book include solutions to the exercises?

The book itself does not include full solutions. A separate instructor's manual exists, and community solution sets are widely available online, though their accuracy varies.

Is the pseudocode tied to a specific programming language?

No. The pseudocode is designed to be readable by anyone who has programmed in any language and avoids language-specific constructs. Translating it to Python, Java, C++, or anything else is a useful exercise.

What is new in the fourth edition compared to the third?

The fourth edition adds new chapters and sections on online algorithms, machine-learning algorithm applications, and updated coverage of randomised algorithms and hash functions. Several proofs and presentations were also revised for clarity.

Is this book appropriate for someone preparing for software engineering interviews?

Yes, though it goes well beyond what most interviews require. If you understand the material here, interview algorithm questions become a small subset of what you can handle. Many readers use targeted chapters — sorting, graphs, dynamic programming — rather than reading end to end.