Customer Reviews

Introduction to Algorithms, Second Edition

5 star:		(52)
4 star:		(32)
3 star:		(11)
2 star:		(9)
1 star:		(10)

 

 

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.

INTRODUCTION TO ALGORITHMS is pretty much the standard textbook in the field of algorithms. In its favor is the fact that it is quite comprehensive, covering a wide range of topics that the beginning student will need to know. On the other hand, it has a tendency towards the confusing and the obscure, with many of the example problems not making a lot of sense. If one decides to purchase this book (and the students will have no choice in this matter, being subject as they are to the whims of their professors), then I recommend that one immediately prints out the "bug correction" page available on the web, as there are several major howlers present in the book, and if one isn't careful then many hours will be lost while one checks and rechecks faulty pseudo-code. In one particularly confused portion of the book, the correction sheet completely replaces three entire pages of the text.

This book covers a huge amount of material, and many of the topics are described quite adequately. Although readers may already be familiar with the numerous data structures that are discussed, the book doesn't assume prior knowledge and goes into quite a lot of detail concerning them. These sections, in particular, are illustrated clearly and offer great reference material that every programmer should have access to. This portion on data structures is one area where the book's conciseness is an advantage. It's simple enough for the beginner to learn from, but it contains more than enough information for the advanced user in need of mental refreshing.

The opening sections that discuss the rudiments of algorithm analysis are also covered competently. The easier subjects don't suffer from the book's shortcomings, as these ideas aren't quite as difficult to understand. For a simple introduction to the easier-to-grasp concepts in Algorithms, these sections simply can't be bettered. It's not until later chapters that some of the material appears incomprehensible.

Other parts of the book are very confusing to the beginning students who, presumably, make up the bulk of the target audience. If this text is used as an accompaniment to a class (as it usually is), then you'll probably do all right. One really needs to have some other source of information, because this book tends to get quite confusing. The problem sets included are frequently obscure, and don't always relate to the material in that chapter. The fact that many of the problems have no given solution (even if one attempts to contact the authors!) is quite telling. The style of the book is extremely dry and occasionally impenetrable, even when compared to other computer science textbooks.

If you're looking at this page, then no doubt you're looking mainly for pricing information, since this book is the definitive standard on the subject. Keep in mind that "definitive" doesn't necessarily mean perfect, and, alas, this book is far from perfection. But if you have an alternative method of learning the material, then this is an excellent book to have as accompaniment. And once you've learned the material, you'll find this to be a great resource.

First, the good part: this book is an intellectual and academic masterpiece. It would be great for people doing algorithm or other Computer Science research. It's an amazing synthesis of much of the core of a Computer Science degree with Discrete Math and Probability. Oddly, it's more like a math book than a CS book.

Now, the not so good part: for implementers (i.e., programmers), this book is not all that useful. The biggest technical negative is that, for the most part, the authors ignore memory hierarchies and treat everything as if it were running on a computer with infinite cache memory and having everything already loaded there. Granted, the authors spend a huge chunk of time teaching the readers how to do (and prove) cost (or efficiency) analysis on algorithms. So, readers should be able to figure out actual, real-world efficiencies on their own (although there's nothing in this book to illustrate how to modify the analysis to do that). But, since memory hierarchies drastically change the relative efficiencies of algorithms, they should be considered in the original algorithmic analysis and ranking.

From a methodology point of view, another problem is that the authors assume the readers have full knowledge of the algorithms covered in the book. In general, they don't even try to teach the actual algorithms, how they came about, the reasoning behind them, or any method of thought for coming up with other, similar, algorithms. Instead, the authors merely focus on proving the correctness and cost of the pre-existing algorithms. It's like the authors present a beautiful, theoretical, shiny structure sparkling and spinning in the ether. They then explain what parts make up this structure, how they're put together, and how long it takes to use such a structure. But, what would be far more useful is if the authors started from the more common position where someone has a problem and a big pile of parts. They need to know how to determine the best thing to make from all those parts to fix the problem, and how to put it together in the most efficient way. Essentially, it's the difference between a reference book and a teaching book.

On the level of irritations, the authors leave a LOT of core stuff as exercises for the student. This is bad enough on its own (and is one of my pet peeves in the math world). However, making this even worse is the fact that NONE of the exercises are answered. So, firstly, that makes these exercises useless to self-studyers (i.e., me). And, secondly, that makes the "proof is left as an exercise to the student" core parts of the book entirely inaccesible to self-studyers.

I can't emphasize enough that academically and intellectually, the scope and depth of this book is amazing. If I were someone doing pure research in computer science algorithms, I'd rate it at 5 stars out of 5. But, as a lowly nouveaux-programmer trying to improve my mind, the best I can give it is an OK 3 stars out of 5.

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.

While working as a software engineer, my supervisor, who also wrote programs for a living, had a book on his shelf, "Data Structures and Algorithms", written by Horowitz and Sahni. It was one of the most tattered-looking hardback books I had ever seen! (a true indicator of the worth of a book). Moreover, I view the Cormer, Leiserson, Rivest book as an updated version of this book, in that it has the same core content of data structures and algorithms, and presents the algorithms in psuedocode instead of a GPL like C++. I find this book, however, not only better written than its predecessor, but also containing a number of advanced chapters (e.g. computational geometry and parallel computation) that reflects the explosion of the study of algorithms over the past 20 years. If I had to choose one book on data structures and algorithms to have on my shelf it would be this one, as no other modern text compares with it in terms of its breadth and depth of the subject material. However, for those students or practitioners who prefer to learn about data structures and algorithms within the context of a progromming language, I recommend Mark Weiss's book on data structures and algorithms, both in Java and in C++. His book seems less developed and rigorous, but he gives good examples, explanations, and more practical insights.

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.

(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 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).

Having never gone to university (I sadly went to a small community college and am, for the most part, self-taught), I didn't know exactly what to expect from this book. From other reviewers, I gathered that this was "the book" on algorithms. I pretty much got the feeling that if I truly wanted a firm grasp on some of the programming algorithms in use out there, this was the book to buy. Boy, was I wrong...

As stated by CJB in his (or her) review (sorry, can't tell your gender by initials ;)), this book seems to be geared towards computer scientists, not so much programmers (and I agree - there IS a huge difference). If you don't have a fairly formal background in math, a fair amount of this book may be a bit over your head (trust me, I know from my sub-university-level math knowledge). Also, if you're not used to (or don't like) reading dry university-style text, then this book probably won't be for you.

However...

If you enjoy challenging yourself (I do), and don't mind spending time on Google looking up things that you don't understand at first, this book may (somewhat) be what you're looking for. One thing I really enjoyed about this book (that other people seemed to dislike) is the pseudocode. If you're a programmer (who knows what they're doing, i.e. not learning the language), seeing an algorithm in pseudocode, no matter what the style is, should be all that you need (and, generally, what you're looking for in a book). The syntax of the implementation is the easy part. I found that by stripping out most of the mathematical junk (the analysis - hey, I only really need to know which one's faster given the current circumstances), I was able to gain a lot from this book.

But again... If you choose to purchase this book (definitely not a waste of money, as some reviewers would have you believe), be prepared for some difficult reading - especially if you're like me and haven't done the whole university thing.

For years, I've looked for a single algorithms book that would cover all of the bases and provide an up-to-date replacement for the 3 Knuth volumes. The 2001 edition of CLR is it. I had looked at earlier versions of CLR and somehow not seen what I wanted; seemed too much like a enumeration of algorithms rather an explanation of them. But what the other reviewers say about CLR is definitely true of this edition. Its the one you want on your shelf to accompany your career in software or computer science.

The reviewers who knocked off stars for being difficult were probably also correct; this book is not for community college course with students who earned Cs in math and programming courses. In fact, I question the word "introduction" in the title. Yes, it only assumes minimal math and programming knowledge, but it goes a long ways into the topic. Sure, it might not cover some exotic academic topics or some very specialized topics, but if you are a software engineer it has all you are likely to want or need in your practical work (until there are new research results that prove important in industry) unless you work in area that requires specialized algorithms.

One topic regretablly omitted from this book, and most other books on algorithms, is extendible hashing, hashing techniques that support an arbitrary, unkown amount of data. Papers by Fagin and Litwin describe such methods.