this book was kept up...no pages missing
was a great deal for me, it beats buyin the book for full price

I received the book in a fairly good amount of time. I will just note that this book did not come with it's companion CD. I expected it to have it's companion cd. There was not mention as to whether or not the book had it's companion cd.

I received the book in a fairly good amount of time. I will just note that this book did not come with it's companion CD. I expected it to have it's companion cd. There was not mention as to whether or not the book had it's companion cd.

I used this book for a graduate level Algorithms course, and I really liked it. It is packed full of content on a wide range of topics. While this book does provide some high-level implementations of algorithms in pseudo-code, you will not find any examples of how to program algorithms in this book. That's really not what this book is meant for anyways.

I found the reading to be easier than Knuth on similar topics, but you still need to have sufficient mathematical background in order to keep up (statistics, discrete math, some calculus). Also, unlike many technical books I've read recently, I did not find any mistakes, not even a typo.

Some people are not aware that the MIT Open Courseware website has some excellent free video course lectures that use this book. I highly recommend at least viewing the first three or four of those lectures if you are new to this topic because they compliment this book very well. Make sure you understand the first four chapters of this book before moving on to other topics.

Also, since it had been a while since I had the math as an undergraduate, I was relieved to learn that this book had several appendices that provided a review of the math topics required by the book.

The only negative about the book is that it does not provide answers to any of the exercises at the end of the chapters, so you really need to use this book in conjunction with a course in order to be able to check your progress and how well you are learning the information. If you're not using this book with a course, check the MIT Open Courseware website that I mentioned previously. It has some sample assignments you can use.

There are three versions of the second edition, only one of which has the CD:

The first one is published by the MIT Press, with the title "Introduction to Algorithms". This one has no CD. This is the one Amazon currently carries, so if you buy from Amazon, you get no CD.

The second one is published by McGraw-Hill, also with the title "Introduction to Algorithms". This one also has no CD.

The third one is published by McGraw-Hill too, but has the title "Introduction to Algorithms and Java CD-ROM". This is the one with the CD. It's much more expensive than the other two.

The CD in the third version contains implementations of the algorithms in Java.

To find someone that carries the CD version, search for this ISBN-13 number: 9780072970548 , or for "Introduction to Algorithms and Java CD-ROM" .

Note: Some listings that come up for the ISBN number will not be the correct version. Look carefully for "and Java CD-ROM" before buying.

This book is (in my opinion) an essential resource of common computer science algorithms. It covers a broad range of different algorithm topics and I found the explanations by the authors extremely helpful and simple to understand (both with simple and advanced topics). It does attempt to cover as many algorithm topics as possible, so some topics may not be covered in fine detail (it does not spend as much time on runtime analysis as other books, or spend much time on NP problems). It is perfect for someone taking an algorithms class (grad or undergrad), or someone looking to broaden their algorithm knowledge. I only wish there was some form of solutions guide to help verify answers to review questions.

If any book is being worshipped for it's content on Algorithms in Academia, then it is this book. I have used this book both in my undergraduate and my Masters and definitely the best in the field.

But, I personally think the topics covered are complex to begin with. So, it takes this book and couple of books for reference to understand the topics completely. If you want to develop new efficient algorithms, then this is the book to begin with. Over all a very good book. Would definitely recommend it.

This book is must have for any software programmer. It is one of the best book I had ever had. It has many mathematical concepts and ppl who are mathematical geeks with software skills will love this book even more like me. This was the first book i bought from Used book section and I am extremely satisfied with the condition. I was quite skeptical when I was buying the book, but the sellers are really good with the what they promised. I am totally impressed and i really appreciate it.
Thanks Guys.

very interesting and fine written book, clearly explained study subjects, plenty of exercises for every chapter

If you look at the preface, the author states "Despite myriad requests from students for solutions to problems and exercises, we have chosen as a matter of policy not to supply references for problems and exercises, to remove the temptation for students to look up a solution rather than to find it themselves." Well, gee, thanks mister author, for you so very high opinion of me as a lazy cheater. I guess I'll just come up with the best answers that I can, and just automatically assume that they're right since I have no correct answers to compare them to. I'm sure glad you have such high principles as you sit up in your MIT ivory tower that you will not be swayed by the masses. I grovel in starry admiration of your intellectual genius and moral superiority. Too bad I have to buy your book for my class.

The first reason: you're taking a course and this is the text. The second reason: you are a working professional and think it might be useful. I have comments for each reason.

If you are taking a course, there is a good chance you will hate this book. This reminds me a lot of the Feynman Lectures of Physics: rapturously admired by people who have already mastered the material; a bit on the brain-numbing side for those who have never seen this stuff before.

This book (despite its bulk) is actually very concise in its treatment of topics. This means that you'll be reading along and suddenly realize it has left you behind. On the other and, it is also very precise, which means your problem is that you missed something. Fortunately, because it is concise, whatever that is is bound to be in the last page or so.

My advice to the student is this: learn to live with the Zen of this book, and you won't hate it. Simply accept that this book will take you on numerous short trips from mystification to epiphany. When you find yourself lost, back up a few paragraphs and really apply yourself. If this were easy stuff, everybody would do it.

For the professional, realize that this is NOT a cookbook. Don't go to this book to examine what an implementation of heap sort in C might look like, although users of languages like Python might be able to use some of the book's treatments of things like graph algorithms that way.

This is a book about designing algorithms, not implementing them. If you need to design an algorithm (much more likely in today's sophisticated, networked, massive data centric applications), this is your text. It is comprehensive, and has useful reviews of things like infinite series and probability that you're probably a bit rusty on.

This is a kind of book a professional wants when his job is giving his company a competitive edge at doing really, really hard stuff. It's not for people who buy books with names like "Visual Basic for Dummies".

If you are a teacher, I would say this: be prepared for students who don't like this book. However this book will get the job done, and will be something students who go on to advanced work will want to keep.

Kleinberg and Tardos, although not the kind of textbook you keep for the rest of your life, may be a better choice on the undergraduate level for several reasons. First, it introduces the material in a more gentle, pedagogical manner. Second, it makes more of an effort to introduce topics using somewhat realistic sounding problems; for me this is neither here nor there but students may be less likely to wonder "why are we studying this?" Third, it has solved exercises. Fourth, it's designed to fit conveniently into an undergraduate curriculum between a data structures course and a computation theory course.

That said, when ten years hence your student runs across a dynamic programming problem and remembers he studied this in school, it is CLRS that will get him back up to speed most quickly.

This book seems to generate strong opinions. I'll try to offer reasons for mine and
base them on examples from the book. I'm sorry this review is so long, but explanations
take more words than emotions. Most of this review was written bit by bit over about
five months, so it might not seem as coherent as I'd like it to be.

There are many errors in this book. It is a big book with a lot of information, so
there is room for a lot of errors. With each printing some of them are corrected.
There is a web site with a list of the errors that have been reported so far, who
reported them, and when they were fixed or will be fixed.
See http://mitpress.mit.edu/algorithms for the error list and other information about the
book. There seems to be fewer errors in each printing, so things are getting better, but
new errors in the first printing (2001), were still being reported in 2006 when the
seventh printing was current. The density of the reported errors decreases toward the back
of the book. I suspect that means fewer readers of the later chapters, rather than fewer
errors, which means the errors will be discovered over a longer time period. But most books
have errors, and based on my experience, computer books have more than most others.
This one is not as bad as some.

Most of my comments here are negative. Balance them against the fact that many instructors
have chosen this text after considering many alternatives. Some of my complaints are general
but supported by only one example. An example, or even several examples do not make the
case. The example documents where "something clicked," when I realized that I had seen
the same flaw several other times.

There were three authors for the first edition, and four for the current, second edition.
It is difficult to make all the chapters seem like they were written by the same person.
The authors did not succeed. Perhaps they did not even try. It does not hurt much.
I noticed the difference only while considering the following problem.

I can not tell what the goal or purpose of the book is. The authors do not seem to have
a clear idea either. The preface tells us it is "a comprehensive introduction" for
"undergraduate or graduate courses in algorithms or data structures" and "equally well
suited for self-study by technical professionals". It claims to be "versatile and
complete", "a mathematical desk reference or an engineering handbook", but "many
interesting algorithms could not be included due to lack of space."

The title is "Introduction to Algorithms" but the book goes well beyond introductory
material, both in depth of treatment and in topics covered. Factoring large integers
and the Fast Fourier Transform are not simple topics. But a little extra is always nice,
so perhaps this really is an introduction.

A lot of the bulk of the book is due to proofs of correctness. This is gold for
some readers and dross for others

There is a lot of math in the book, but it is not uniformly mathematical or uniformly
rigorous. Sometimes it seems the authors do not know what level they are trying for.
Chapter 5 is "Probabilistic Analysis and Randomized Algorithms." It says "If you are
unfamiliar with the basics of probability theory, you should read Appendix C, which
reviews this material." Appendix C says "This chapter reviews elementary combinatorics
and probability theory. If you have a good background in these areas, you may want to
skim the beginning of the chapter lightly and concentrate on the later sections."
Section C.5 is an advanced discussion of the tails of the Bernoulli distribution.

Some of the math sections are fairly advanced. There are subtle points I never saw before
in spite of my BS Math. In other places the math is overly simple. Appendix A is a review
of summations. There is a formula for the sum of the simplest arithmetic and geometric series,
but the general cases are ignored. Overall the level of the math seems close to "right."
If the title were changed to "Introduction to Algorithms and Analysis of Algorithms" then
the level would be fine. Readers uninterested in the mathematical analysis of the algorithms
or unable to follow the analysis need not despair. Most of the results are also presented in
English. This book is probably (just a guess) as good as most of the lighter, thinner,
and less expensive tomes for those readers.

The technique of partial fractions is used several times with the results presented as if by
magic instead of as the result of a simple technique. One sentence "look up partial fractions
in any calculus book" would help some readers. However, there is an extensive bibliography and
many pointers to one or more sources for many topics.

Many reviewers have complained about the pseudocode and I agree it is a weakness of the
book, but it is not a total mess. It is not APL or even similar to APL. It is closest
to Pascal, but there are differences. Variables are local unless otherwise indicated,
and that is fine. Variables are not declared and that is fine. Block structure is
indicated by indentation instead of words or symbols that mean begin and end, and that
would be fine except that the authors do not follow their claim. Instead, an apparently
meaningless keyword "do" introduces many blocks. It may have a meaning, but I could not
find it since it is not in the index. The result of the "do" is a block appears with mixed
indentation. Also, the indentation from one level to the next varies from place to place,
apparently from 3 to 7 spaces. It is hard to tell. I suspect the pseudocode is set in a
variable width typeface with spacing added to make it look fixed width. Perhaps the "do"
is a residue from Pascal where it is used to terminate the test portion of a WHILE or FOR
statement. If so, most style guides would have it with the test, rather than with the
block controlled by the test. I believe most readers would find it easier to understand the
pseudocode if they used a bottle of "whiteout" to erase all the instances of "do".

Assignments are done with an arrow instead of Pascal's ":=", and that is fine.
Comments are introduced by a special triangle symbol instead of any of the common
comment symbols. I can not imagine why.

In Pascal, functions return the value stored in the variable with the name of the function.
The pseudocode uses return statements which can have explicit values, and that is fine, (an
improvement in my opinion) but the return statement is not mentioned in the index.

Arrays are indexed from 1 to n, instead of from 0 to n-1. This is not a fault. The debate
over which is best has gone on for decades. Readers will have to adjust the index if they
compare the algorithms presented here with those in a source that uses Java, C, etc.
In at least one case, they also use zero base. In the section on Bucket Sort, the algorithm
uses both with no reason given for either.

The lack of answers to any of the problems can be a problem to most readers and will be
a major problem to those using the book for self education. Some answers can be found on
the web pages maintained by some CS instructors who use the text. I have no idea what
fraction of the answers are available, and offer no tips for finding them. The lack of
answers is made worse by another characteristic. Many claims are made in the text, with the
proof deferred to a problem. Sometimes the problem makes a further reference, even to a
different chapter. For example, the discussion of double hashing depends on problem 11.4-3,
which contains the hint "See chapter 31." Some readers might be willing to use a result
from a problem without seeing the proof. This is not always possible. Some problems express
something about an algorithm, perhaps a formula for running time, or a post condition, or a
fragment of implementation, or perhaps several alternative claims, and then ask which if any are true.

The authors deserve a star for intellectual honesty. Many authors freely lift historical
notes from elsewhere and repeat the information. Here, the historian (often Don Knuth)
is given credit as well as the inventor.

Some algorithms are presented in a recursive form when an iterative form is well known,
and sometimes much better known, and usually the original form. Merge sort is a good
example. This bias to the recursive form usually makes the analysis of run time easier
but might lead some developers to an inefficient implementation. I found a few cases where
the iterative form was mentioned in an exercise or problem. For example, in quicksort,
which partition to stack and which to sort is not asked, but can be discovered by solving
a problem on p162. Even Euclid's algorithm for the greatest common divisor is presented
as recursive. Exercise 31.2-4 asks for an iterative version.

In spite of the bulk of the book, it is not complete. For most topics it is not complete.
The authors do not claim it is complete; they explicitly state it is not. In general,
they have made a reasonable choice of material. Consider binary trees. There have been
many inventions for keeping binary trees in reasonable balance in spite of biased additions.
The authors ignore most of them. They provide very good coverage of red-black trees, which
may provide the best tradeoff between best possible balance and least effort spent adjusting.
Splay trees and skip lists get a few lines each.

There is a 17 page bibliography of 320 items.

The index is 36 pages of two columns, but it is not complete. It seems to cover some topics
thoroughly, but others less so. Definitions seem to be covered, but uses are often ignored.
For example, Sterling's approximation to n! is indexed where the formula is given, but not
any of the places where it is used. The entropy function is used as an example several times,
but is indexed only where it is defined. Some special notation conventions are explained
where they are introduced, but then not used immediately. The reader wondering what it is
good for is lost. The index does not help.

Some reviewers have berated reviewers that have not read the entire book. I plead guilty.
I'm using the book for a class that covers 20 of the 35 chapters, the first 15 and the five
chapters about graph algorithms. The book is good enough that I will probably read most
of the other chapters when I have the time.

The background of other reviewers seems to greatly influence some of their reviews.
So readers of this one can compensate for any of my biases, here is my background.
I'm a retired software engineer, having programmed digital computers since 1960.
BS math '68, MS CS '93. I wanted to take a class as part of my brain-rot prevention plan.
I picked one about analysis of algorithms because I'd seen a little of it in Knuth's books
and elsewhere, but had never done much of it. I've built and used many of the algorithms
discussed in the book. There may be topics that are poorly presented that I would not notice
because of that familiarity. There may be topics that are presented better than in any other
book that I would not notice because of that familiarity.

This paragraph was added more than a year after I finished the course that used the book.
It has drifted to the dusty end of the shelf. I use Knuth every few weeks and Skiena
occasionally. This tome was touched once, when a three page chapter on the Fast Fourier
Transform seemed too terse. After scanning the 27 pages here I went back to the three page version.

I have been using this book since 1995 (that was the first edition; the second is much better). It is a great book, and presents the subject in an incredibly clear way: too often I found that I didn't have to go back and re-read a paragraph or anything. The authors are excellent writers.

One thing I didn't like was the chapter on NP-completeness. It seems to be less clear than the rest of the book, but then maybe it's just me.

The exercises are good -- there are easy, medium and hard ones.

But even this book being excellent, I would recommend others as well -- some other books have a better coverage of parallel, distributed, approximated algorithms, and the theory of computational complexity is barely scratched in this book.

And one thing that I see people complaining about (and I agree with them) is the total absence of answer to exercises. There are some problems with this:

* People who study on their own have no way to tell if they really got it right. It's not an easy subject, and looking up the answer to get some positive reinfircement after you finished an exercise is an excellent way to enhance and speed up the learning process, as well as spotting mistakes;

* Not making answers available is some kind of message to instructors: "Don't bother creating your own sets of exercises; use those from the book, the students won't know the answers anyway". There are instructors who will use exercises from this book on tests (!) -- this is not good. Teachers should be able to come up with their own exercises and tests, and ***change them every time they teach the course!*** (I once saw a student with a pile of resolved exercises on Compilers. He said the teacher would always use exercises from a certain list in his test)

So, really... Not publicizing answers to at least part of the exercises makes no sense (that's why I am not giving it 5 stars).

The aspect I like the most of CLRS book on algorithm is that, the style of the book is lucid, the authors have made a sincere effort in putting forth the complicated aspects in analyzing the algorithm in way that could be understood by a wider audience taking some course in computer science in under-graduate or graduate level. The mathematical rigor makes s me wonder computer science algorithm analysis is nothing more than applied discrete mathematics for specific problems.

I bought a new copy of the book, and was happy to receive it the way I expected. Got free shipping with this one.

This book does not provide enough examples to really get the ideas across. It is a thick read that provides little help to the subject matter unless the reader already has a wealth of knowledge on mathematical proofs and algorithms to begin with.

If the book had a solution manual, or at least explained many of the things that occur in the problem sections that never show up in the actual reading, then it would be a much easier to understand textbook.

This is one of the few books that I've kept from my undergrad days as a computer science major. Although I haven't been doing software development in a while, I still use it for reference once in a while. It's easy to understand and timeless reference book. I work for a large DoD company and quite a few of my co-workers have this book on their shelves as well. (We all went to different colleges.)

This is a good reference for researchers, but it is not suitable for beginners. For anyone who try to study algorithms in the beginning, he just needs the big picture of this course, but this book contains too many mathematical proofs. In other words, the beginners just want a cup of milk, but the authors of this book give them a whole cow.

Although this book is quite huge, it does not contain some important topics, like online algorithms, randomized algorithms ... etc. In fact, this book should try to 'lose its weight' in order to get more useful knowledge.

The book contains a lot of interesting exercises, but does not indicate any hints or solutions. In fact, some of those exercises are too hard for students, and the authors should try to announce all sloutions in the website.

+ Defacto standard
+ Accompanying WebCourse

- Too deep if used as an intro book; lacks solutions if used for a reference book
- It's HUGE!; hard to carry around

= Tries to appease too wide an audience. Definately attractive to professors who already know the information and feel this is THE book yet probably too deep for an intro algorithms class. Wish there was a searchable pdf version that came with the book on a CD as well as odd numbered solutions.

+ Defacto standard
+ Accompanying WebCourse

- Too deep if used as an intro book; lacks solutions if used for a reference book
- It's HUGE!; hard to carry around

= Tries to appease too wide an audience. Definately attractive to professors who already know the information and feel this is THE book yet probably too deep for an intro algorithms class. Wish there was a searchable pdf version that came with the book on a CD as well as odd numbered solutions.

What it is:
A very thick text book about a) the mathematics behind algorithms, and b) a treasure chest of random performance tips.

Who it's for:
This book is for those who want or need to gain a decent grasp of the math for analyzing algorithms, and already have a decent understanding of discrete mathematics and probability.

What's good about it:
I really like this book. It's very high quality, well written, concise, and clear, and it's sprinkled with clever little tips to improve the efficiency of common routines.

Tips:
You can watch video recordings of the MIT lectures based on the book. Check out "6.046J Introduction to Algorithms" by searching for "ocw 6.046J" in your favorite search engine. The mathematical prerequisite course is also available in text form on MIT's OpenCourseWare; it can be found by searching for "ocw 6.042J spring 2005".

Warnings:
* Don't bother with this book unless you have a high aptitude for math
* Don't bother with this book unless you're prepared to work at it
* It's not designed as a reference book; instead it's a study book.

Many reviewers have called this book a "reference", but I have to disagree. A good reference book makes information quickly accessible, but this book would require you to read way too much to be called a reference. A practical reference book for algorithms is "The Algorithm Design Manual" by Steven S. Skiena, assuming you don't require proofs.

The Major Shortcoming!
Given that the book's design is most appropriate for learning things you don't already know, it has one major shortcoming: there are no answers to any of the exercises or problems. That makes the book semi-useless for self-study as well as for instructors who believe in the pedagogic value of students being able to check their answers. The instructor's manual is only available to instructors on the condition that they don't make the answers available.

What it is:
A very thick text book about a) the mathematics behind algorithms, and b) a treasure chest of random performance tips.

Who it's for:
This book is for those want or need to gain a decent grasp of the math for analyzing algorithms.

What's good about it:
I really like this book. It's very high quality, well written, concise, and clear, and it's sprinkled with clever little tips to improve the efficiency of common routines.
Also, you can watch the MIT lectures based on the book. Check out "6.046J Introduction to Algorithms" at:
[...]

Warnings:
* Don't bother with this book unless you're have a high aptitude for math
* Don't bother with this book unless you're prepared to work at it
* It's not designed as a reference book; instead it's a study book.

The Major Shortcoming!
Given that the book's design is most appropriate for learning things you don't already know, it has one major shortcoming: there are no answers to any of the exercises or problems. That makes the book semi-useless for self-study as well as for instructors who believe in the pedagogic value of students being able to check their answers. The instructor's manual is only available to instructors on the condition that they don't make the answers available.

The de facto standard for many algorithms courses. It's a great text with well-structured proofs, examples and exercises. It's also a great reference that I constantly find on the shelves of co-workers. Definitely a keeper that will come in handy for years to come.

Definitely not for those without a strong discrete math background. This book gives you the foundations and not just code.

Cheaper than the bookstores as always.

This is a comprehensive book that covers major areas of algorithms for software developers and students. I would rate it as an intermediate book and have used it for learning up topics out of sequence. I still find myself using Wikipedia or other books for better readability or a variation in approach.
The broad areas include Sorting, HashTables, Tree (Binary Search, Red Black, Graphs, String Matching, NP complete problems and the algorithms are in a psuedo code format. Most of the chapters includes proofs for correction and runtime analysis and problems to solve as an exercise.
There is a 3 chapter appendix for Mathematical background and explaining notations.
The latest printing (eight I believe) of second edition is from 2003, the one from 2001 (3-5 printings) have a slightly larger errata.

[...].

This book has a lot of information, but the class I had only covered about half the book. I wish this book only had that half because it was a chore hauling this thing around with me at school.

In my experience, this is the book by which other algorithm texts are measured. The authors are comprehensive and knowledgable. I've actually had people come up to me after noticing me reading the book and say: "Hey, I took that class!".

One criticism is the lack of graphic depictions of many of the algorithms and concepts being presented. I'm a visual learner and I found myself totally baffled by some of the text-only explanations. I would LOVE to see Java animations of each algorithm/concept included on the CD-ROM. There are web sites that provide some of these animations but they don't always match one-for-one with this books version, plus you have to spend an undue amount of time searching for them.

A comprehensive book. Used a little of this book in my analysis of algorithm class. A good book for later reference

Overall this is a good book and well worth every cent. The material is covered better than most data structure text books. It also avoids using recursion in situations when its not needed. For example, the texts chapter on red-black trees is probably the best I've seen. It explains key concepts while building on previous knowledge with notes to where the previous material was covered. The red-black tree is explained without using recursion, because the authors were smart enough to have realized the general reader cares about creating practical data structures without any or much lost in performance. Cormen et al does this well indeed. Each algorithm is laid out in pseudo-code that can easily be adapted to code in any language. One of my dissatisfactions was with the presentation of the pseudocode in that the indentation was done in a strange manner. This made the scope of the blocks of logic in certain algorithms confusing. Furthermore, the binding of the book is quite fragile and would most likely be broken with casual use as a textbook in college. However, I suspect the author did this to lower the price for college students and I thank him for that. In conclusion, this is near perfect book and is the reason why I give it four stars instead of five.

If you are seeking a good data structure or algorithm textbook, then you cannot go wrong with Introduction to Algorithms.

I'm very satisfied with this purchase. Fast delivery, perfect guarantee with complete coverage, %100 trust-worthy.
Thanks Amazon.

I have read two algorithms books (Van Gelder and CLR), and CLR is by far the best. The explanations are very clear and concise. The book also serves as an excellent reference as the subchapters are fairly self-contained, making it easy to read up on a small detail. If you are looking for a more detailed discussion on NP-completeness and computing theory, other books (e.g. Sipser or Hopcroft) are more appropriate.

This book has the professional in mind, every page is simply explained ( in perspetive to the subject matter ). This isn't a beginner book for programmers, this is a beginner book for Algorithmic study, these are not the same matters; however, internally they are. If you are competent in coding the language, now it is time to break the bounds of coding and enter the world of programming. The only problem I have with this book is that it is sort of a cook book; it is not an exaustive teaching of algorithmic developement, it is more a history of algorithms that have been found useful in career.
Although this book is very light on each algorithm group, and does not require in-depth knowledge of the code to program it, it does however paint a good picture of how to use the algorithm; in contrast, the art of computer programming is much more exaustive but can be hard to follow if you don't know the uses of an algorithm.

Puzzle: "as easy as 123"; what is unique about this sentence?
hint; sometimes all of us wear masks to hide our identity, but sometimes it is the identity we hide that is the mask.

This is actually a very good book to read - what they cover, they cover in depth, building each concept up from elementary concepts so you can always see how they got from point A to point B. The authors present mathematical proofs of essentially every assertion (although, as is typical of "discrete math" proofs, the proofs can sometimes be a tad on the silly side as they sometimes just restate whatever they're trying to prove - blame academia). The algorithms are all presented in a language-agnostic pseudocode which highlights the essentials of the algorithm itself without burdening the reader with language idiosyncracies. Plus, if you want something more concrete, the latest edition comes with a CD-ROM including all the algorithms implemented in Java!

So, this is an excellent reference on the subject of algorithms. But as a textbook? It's horrible. One of the worst. Although the book is replete with problems and questions, there are no answers provided. To any of them. You can't purchase an answers/solutions book. You can't look up the answers on a website. The authors are openly hostile towards anybody who might (imagine this?) want to verify whether or not they got the correct answer on any of the questions. The fact is, it's clear from the author's demeanor that they WANT YOU TO FAIL. They don't want you to be able to learn algorithms from this book - they intend it to be a thorough reference for anybody who already understands the subject material.

They defend their position by asserting that they can't provide answers to students since some professors copy the problems verbatim from the book onto their exams. (They even provide a professors-only solution guide for professors who assign problems that they themselves can't solve). Fortunately for me, I'm lucky enough to be taking a course taught by a professor who actually does understand his own material, and he's been kind enough to help me through the questions I can't figure out. It's a shame I have to waste so much of his time thanks to the utter arrogance of the authors of the textbook we use.

So, as long as you have another source to learn algorithms, this is an excellent reference. If you plan to learn, look elsewhere.

This book is not for the casual reader. If the contents seems confusing at times it is because there are hard problems being analyzed. Any book on algorithms that is not confusing at times is probably not discussing any interesting algorithms. While quite academic, this book is also relevant to any engineer who needs to design/optimize a non-trivial algorithm. It's also one of those books that one can open up to any random page and start reading. Sometimes when I get coders-block, this is just the thing to break me out of it. This book is heavy, expensive and well worth its weight and price.

This is an excellent book. Well written, easy to understand, precise, good problems, excellent coverage of the basics. This book can provide an excellent foundation in computer science.

To customers: please report any inappropriate reviews, such as those given by readers who haven't read the book.

I consider this to be the undisputed algorithm "bible" for introductory computer scientists. This was a textbook of mine in graduate school. Great exercises, good explanations. Highly recommended for anyone involved with algorithmic implementation.

I just heard about this book in an interview and thought I'd check out the reviews. Once I read one 5 star review from one of the authors and another from someone claiming to not have read the book but wanting to give the authors the benefit of the doubt, I decided I should enter a one star vote to balance things out a bit. This is not to say the book doesn't deserve 5 stars, but this should be left to those who have actually purchased and read the book, not those who haven't or the authors of the book. After submitting this review I will be reporting it as inappropriate just as I have for the author's vote and the "benefit of the doubt" vote.

I gave this book 5 stars for the benefit of the doubt because I have not read it yet.

To the author, might makes things clearer if you allowed folks to examine a handful of pages like most other publishers/authors do on Amazon.

Pierre - Great review! :|

Yes, this is the HOLY BOOK OF ALGORITHMS. It is both detailed and concise. But I do not think that it is for introductory level algorithm courses. Rather it is appropriate as a reference.

(1) i have taken courses that use this book
(2) i have taught students from this book

in both cases the book was not useful. the professor provided online notes as a supplement to the book because, frankly, the book is opaque at times and not at the level of an introductory course.

in case (2), when i actually interacted with students trying to learn the material, i found that students just had a lot of trouble understanding many sections of the text.

i own this book because i do a lot of work on algorithms and it's good to have on the bookshelf, ready to grab. but i don't think people should teach from it, nor should the casual student of algorithms own it. instead, there are much better teaching books. the new Kleinberg and Tardos book is a great example of a book that's good for teaching.

I have not yet read or started this book. I'll let you know surely once I get to it. Thanks

I really liked this book, so easy especially when you have a solid background in Discrete mathematics, while I'm not a pascal fan but using Pascal like Pseudo-code was tolerated giving respect to how organized and self contained the content of this book is, it's great that it can be used as an introduction as well as an advanced read for algorithm, few books can do that.
Should be on the shelf of every programmer.

I am an older student (older than 40) and completed a MS in computer science about 12 years ago. I recently enrolled in an algorithms course at a local university mostly to brush up on areas that I haven't looked at in a long time. I have been using this book for about 6 weeks.

In general I like how the book is written but gave it 1 star because I find it very frustrating that there are no answers to any of the exercises or problems.

The exercises and problems seem to exist mainly as a source of test questions for professors (my opinion). Cormen has published the following on his website regarding solutions to the exercises: "please do not ask me for solutions; I will not respond. (I used to post names of those who asked me for solutions. I have since decided that this practice is nastier than necessary, and so now I just do not reply.)"

For a guy who wants $80+ a book, this seems to be a rather condescending attitude to take.

Anyway, I have spent a lot of time working on these questions but have no way to know for sure if my answers are correct or not. I am sure I will found out in a few weeks after our midterm whether or not I understood the material. Unfortunately, that valuable feedback will come AFTER I receive my grade.

In short there is tremendous demand for an algorithms book that has both questions and answers. If Cormen and company can't meet this need, then perhaps there are some other knowledgeable people out there who can write one. If you do, let me know. I'll be the first to buy it.

If you're looking to LEARN algorithms this is not the book for you. The authors' writing style is excruciatingly verbose and the structure is haphazard. I do not understand why algorithms exhibiting similar techniques (e.g. dynamic, greedy, etc) are not clustered together. Another peeve is the fact that critical parts of proofs and explanations are left to the reader. And of course, there is no solution manual available to the public.
So if you would like to learn algorithms, please check out Anany V. Levitin's book. Although his writing style may be considered simplistic he conveys the information in a style suitable for learning. I hope the authors (CLRS) will one day realize that simplicity is elegant.

An algorithm is nothing more than a set of computational steps that transform a specific input into a desired output. From that definition, there are plenty of books on the market that are "cookbooks" of algorithms and will enable you to do just that - transform specific inputs into outputs, complete with source code, and with no real depth of understanding of your own required. However, to be a computer scientist versus a programmer, you need to know what makes an efficient algorithm, why is a particular algorithm efficient, what kinds of common data structures are involved in various computing problems, how to traverse those data structures efficiently, and a notation for analyzing various algorithms. This book will help you learn all of that. The study of the theory of algorithms is not to be undertaken lightly, and I don't recommend you attempt to self-study such a complex subject with such strong mathematical underpinnings. In fact, this book is really aimed at graduate computer science students and is often on the reading list of Ph.D. qualifying examinations in that field.
For students of graph theory, you might find your knowledge solidly supplemented by the material in chapters 22 through 26 on graph algorithms. The last section of the book, "Selected Topics", goes over various specific algorithms from many fields using the knowledge of algorithm design and analysis you have learned up to this point in the book. Throughout, the text is very clear, and there are plenty of instructive diagrams and pseudocode.
One of the most interesting parts of the book is the chapter on NP-completeness. This is the study of problems for which no efficient algorithm has ever been found. These problems are interesting for two reasons. The first being that even though an efficient algorithm has never been found, there is no proof that one cannot exist. Second, if an efficient algorithm exists for one of them, then an efficient algorithm exists for all. Thus, if you are ever called upon to write an efficient algorithm for an NP-complete problem, you will be involved in a long fruitless search if you do not recognize the problem as NP-complete. If you can show the problem is NP-complete, you can go about producing an algorithm that gives a good solution, but not the best possible solution. This kind of knowledge is what separates a computer scientist from a mere programmer, and is one of many reasons to study this book's contents. I highly recommend this book to anyone who truly wants to be called a computer scientist.
To get the most from this book you should already be familiar with discrete mathematics and combinatorics, as this book makes heavy use of these subjects. Because this book contains no solutions to any of the exercises, might I suggest "Problems on Algorithms" by Ian Parberry as a companion to this book. It has a little bit of tutorial and a lot of exercises, many unsolved, but some with hints and others with solutions. Also, for more basic material, you might look at "Schaum's Outline of Discrete Mathematics". It's very inexpensive and can almost stand alone as a tutorial on the mathematics you need to know to succeed at understanding this book. I notice Amazon does not show the table of contents, so I do that here:
Foundations
1 The Role of Algorithms in Computing
2 Getting Started
3 Growth of Functions
4 Recurrences
5 Probabilistic Analysis and Randomized Algorithms
II Sorting and Order Statistics
6 Heapsort
7 Quicksort
8 Sorting in Linear Time
9 Medians and Order Statistics
III Data Structures
10 Elementary Data Structures
11 Hash Table
12 Binary Search Trees
13 Red-Black Trees
14 Augmenting Data Structures
IV Advanced Design and Analysis Techniques
15 Dynamic Programming
16 Greedy Algorithms
17 Amortized Analysis
V Advanced Data Structures
18 B-Trees
19 Binomial Heaps
20 Fibonacci Heaps
21 Data Structures for Disjoint Sets
VI Graph Algorithms
22 Elementary Graph Algorithms
23 Minimum Spanning Trees
24 Single-Source Shortest Paths
25 All-Pairs Shortest Paths
26 Maximum Flow
VII Selected Topics
27 Sorting Networks
28 Matrix Operations
29 Linear Programming
30 Polynomials and the FFT
31 Number-Theoretic Algorithms
32 String Matching
33 Computational Geometry
34 NP-Completeness
35 Approximation Algorithms
VIII Appendix: Mathematical Background
A Summations
B Sets, Etc.
C Counting and Probability

An algorithm is nothing more than a set of computational steps that transform a specific input into a desired output. From that definition, there are plenty of books on the market that are "cookbooks" of algorithms and will enable you to do just that - transform specific inputs into outputs, complete with source code, and with no real depth of understanding of your own required. However, to be a computer scientist versus a programmer, you need to know what makes an efficient algorithm, why is a particular algorithm efficient, what kinds of common data structures are involved in various computing problems, how to traverse those data structures efficiently, and a notation for analyzing various algorithms. This book will help you learn all of that. The study of the theory of algorithms is not to be undertaken lightly, and I don't recommend you attempt to self-study such a complex subject with such strong mathematical underpinnings. In fact, this book is really aimed at graduate computer science students and is often on the reading list of Ph.D. qualifying examinations in that field.
For students of graph theory, you might find your knowledge solidly supplemented by the material in chapters 22 through 26 on graph algorithms. The last section of the book, "Selected Topics", goes over various specific algorithms using the knowledge of algorithm design and analysis you have learned up to this point in the book. The topics covered include sorting networks, matrix operations, linear programming, the FFT, number-theoretic algorithms, string-matching, computational geometry, NP-completeness, and approximation algorithms. Throughout the book, the text is very clear, and there are plenty of instructive diagrams and pseudocode.
One of the most interesting parts of the book is the chapter on NP-completeness. This is the study of problems for which no efficient algorithm has ever been found. These problems are interesting for two reasons. The first being that even though an efficient algorithm has never been found, there is no proof that one cannot exist. Second, if an efficient algorithm exists for one of them, then an efficient algorithm exists for all. Thus, if you are ever called upon to write an efficient algorithm for an NP-complete problem, you will be involved in a long fruitless search if you do not recognize the problem as NP-complete. If you can show the problem is NP-complete, you can go about producing an algorithm that gives a good solution, but not the best possible solution. This kind of knowledge is what separates a computer scientist from a mere programmer, and is one of many reasons to study this book's contents. I highly recommend this book to anyone who truly wants to be called a computer scientist.
To get the most from this book you should already be familiar with discrete mathematics and combinatorics, as this book makes heavy use of these subjects. Because this book contains no solutions to any of the exercises, might I suggest "Problems on Algorithms" by Ian Parberry as a companion to this book. It has a little bit of tutorial and a lot of exercises, many unsolved, but some with hints and others with solutions. Also, for more basic material, you might look at "Schaum's Outline of Discrete Mathematics". It's very inexpensive and can almost stand alone as a tutorial on the mathematics you need to know to succeed at understanding this book.

An algorithm is nothing more than a set of computational steps that transform a specific input into a desired output. From that definition, there are plenty of books on the market that are "cookbooks" of algorithms and will enable you to do just that - transform specific inputs into outputs, complete with source code, and with no real depth of understanding of your own required. However, to be a computer scientist versus a programmer, you need to know what makes an efficient algorithm, why is a particular algorithm efficient, what kinds of common data structures are involved in various computing problems, how to traverse those data structures efficiently, and a notation for analyzing various algorithms. This book will help you learn all of that. The study of the theory of algorithms is not to be undertaken lightly, and I don't recommend you attempt to self-study such a complex subject. However, even if you do this is a good solid text. For students of graph theory, you might find your knowledge solidly supplemented by the material in chapters 22 through 26 on graph algorithms. The last section of the book, "Selected Topics", goes over various specific algorithms using the knowledge of algorithm design and analysis you have learned up to this point in the book. The topics covered include sorting networks, matrix operations, linear programming, the FFT, number-theoretic algorithms, string-matching, computational geometry, NP-completeness, and approximation algorithms. Throughout the book, the text is very clear, and there are plenty of instructive diagrams and pseudocode.
One of the most interesting parts of the book is the chapter on NP-completeness. This is the study of problems for which no efficient algorithm has ever been found. These problems are interesting for two reasons. The first being that even though an efficient algorithm has never been found, there is no proof that one cannot exist. Second, if an efficient algorithm exists for one of them, then an efficient algorithm exists for all. Thus, if you are ever called upon to write an efficient algorithm for an NP-complete problem, you will be involved in a long fruitless search if you do not recognize the problem as NP-complete. If you can show the problem is NP-complete, you can go about producing an algorithm that gives a good solution, but not the best possible solution. This kind of knowledge is what separates a computer scientist from a mere programmer, and is one of many reasons to study this book's contents. I highly recommend this book to anyone who truly wants to be called a computer scientist.
Because this book is sparse in the solved problems department, might I suggest "Problems on Algorithms" by Ian Parberry as a companion to this book. It has a little bit of tutorial and a lot of exercises, many unsolved, but some with hints and others with solutions.

If you are tired of algorithm books that are obscured by reams of coding in a particular language--c++ ,java, perl, etc--and are looking for a more mathematical bent (meaning proofs) to algorithm analysis then this real gem of a book is for you. I consider CLR to be an "advanced" algorithms text that covers all the major algorithmic concepts while paying homage to the works of Aho, Knuth and other famous algorists. The pseudocode used in CLR is very clear and is complemented by excellent prose descriptions. I especially enjoyed read ch.34 on NP-Completeness.

I'm a sophemore and I have had this book for over two months.Instead of reading this book from cover to cover,I use it as a referance manual for my course of Data Structure and Algorithms.This is an excellent book indeed.However,the pseudocode in this book has costed me a lot of time.As the author has said,all sourcecodes in Java are avilable from another book,that's fine.I suggest the authors translate all the codes into C,C++ and other languages,Or they can have them translated.This would not be a difficult job.

I have used this book to teach a junior level course in algorithms in fall-05. This book is exactly what its preface says it is - a buffet of algorithms. Instructors can pick and choose what to teach from it. Do not even attempt to teach the whole book in one semester. It's encyclopedic.

The pros:
Lots of algorithms to choose from. Covers a very wide array of subareas in algorithms. Detailed analysis of many algorithms that could overwhelm even graduate students. Written in clearly separated sections allowing an instructor to choose what portions to teach to an undergraduate class and what portions to include for a graduate level class. Lots of problems at the end of each section.

I liked the fact that this book included an introduction to computational geometry, but wished they had included some more material like planarity of graphs and voronoi diagrams. The chapter on dynamic programming was good and gave both me and my students a clearer idea of what dynamic programming is about.

Voluminous enough to use as exercising weight or mugging someone. Decent font sizes and printing quality.


Cons:
The book tends to go very often into abstract and obscure mathematical proofs of run-times and correctness without explaining any reasoning of how or why an algorithm was designed the way it is. It leaves the students (and instructors) wondering "How in the world did somebody come up with this stuff?". That is, this book is mainly about "analysing" the run-time complexities rather than the "design" of the algorithms. I feel there were several occassions in which simpler rather than ultra-rigorous proofs could have been presented.

Some of the algorithms seemed unnecessay (Strassen's algm can do matrix multiplication in O(n^2.83) instead of O(n^3) if the programmer is willing to slice and dice and juggle matrices in some really funky ways .. No thanks!).

Instructors have access to the solutions manual - which includes solutions to "some" problems, but not all. Can be very overwhelming for undergrad students who are usually not attuned to mathematical notations.

I would actually give this book about 3.5 stars instead of the 4 that I have indicated (but that option does not exist).

For many readers, this book will be no mere "introduction".