Introduction to Algorithms Reviews

• A definitive guide, but not perfect

  
  By A2I17T9XB6LSGW on 2002-05-28
  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.
  
  

• Academic Masterpiece, Practical White Elephant

  
  By A3DQWFWINN3V5A on 2005-09-05
  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.
  
  

• Complete, thorough...

  
  By on 1999-08-04
  Quote from a previous review:

  Instead of touching on new technologies, such as AI, graphics, or anything else remotely relevant to today's demands on programmers and designers, this book, faithful to its MIT roots, gives a pompous, eggheaded distortion to the field of computers as a whole. Its focus is mainly on such trivialities as algorithm analysis, offering about 10 pages of proofs for each simple assertion. The points that the authors hope to make have no relevance whatsoever in a world in which processor power, not meticulous code optimization, reigns.

  ----------

  I've had Cormen (one of the authors) as a professor in class, and my algorithms class uses this book, so admittedly my view might be a bit biased. But if you read the above (quoted) review, you might have gotten the wrong impression about this book. Cormen et. al. *intentionally* left "AI and graphics" algorithms to other authors; this isn't the place to cover those topics enough to do them justice. And as someone who has actually read the book, each proof is *not* 10 pages long. The examples are usually quite good, and concisely (if thoroughly explained). Finally, prof. Cormen always explains to his intro CS students why the study of algorithms is important, even as computers get faster and faster: some problems, poorly implemented, just *will not* run as well on a machine of today compared to a much older machine running a better algorithm. There will *always* be a justified place for the study and analysis of algorithms. Had the previous reviewer actually had met Prof. Cormen, he wouldn't be able to write the book off with the title of "pompous" or "eggheaded" either...
  
  

• A Very Solid Introduction to Algorithms

  
  By A1ZIUDIBLI7Y7F on 2000-12-08
  It's a good thing that this book has a hard cover (make sure you get the hard cover edition, huh?), because otherwise mine would be in pieces. This book is my favourite book on algorithms. All the others seem somewhat unsatisfactory to me -- they are tied to particular programming languages, they are paperback, and they are for the most part less comprehensive than this book. (except Knuth, which is somewhat more advanced). See the summary of the TOC below for an outline of what the book covers. I guess Sedgewicks new title has been getting better reviews, but it's still not hard cover (-;

  This covers a lot of topics, and covers them in some level of mathematical rigor. For example, all assertions about algorithm efficiency are backed up with *proofs*, and key concepts like asymptotics, and big-O notation are covered. To those who think proofs are not essential -- as a mathematician, I'd counter that proofs are absolutely necessary, because you don't know something until you've proven it -- it's easy to make wrong "guesses", or even wrong hand-waving arguments. The examples are all in pseudo-code. Personally, I liked this as it makes implementing the data structures an interesting exercise that forces the reader to think.

  The subject matter covered is quite broad, see below. There are some interesting topics that don't get covered (eg AVL trees), but this book does a good job at laying down the foundation.

  Some might be intimidated by the theoretical approach, but I for one like it. It's written for computer scientists (or "software engineers"), not get-rich-quick wannabees. This book will force you to think, and if you don't like that, well you can (and should) buy "learn algorithms in 21 seconds" from SAMS or something.

  You'll need some background to digest this material. Someone with a year of programming and some discreet math should be ready for it. Note that you won't learn any programming *language* from this book (unless you count pseudo-coed), so you'd better know some before starting !

  Summary: PartI: Intro, Growth of functions,Summations, Recurrences, Sets, Counting and Probability

  Part II: Heapsort,Quicksort, Sorting in linear time, Medians/order statistics

  Part III: Stacks/Queues/Linked lists, Hash tables, Binary search trees, Red-Black trees, Augmented data structures

  Part IV: Dynamic programming,Greedy algorithms, Amortized analysis

  Part V: B-trees, Binomial heaps, fibonacci heaps, data structures for disjoint sets

  Part VI: Elementary graph algorithms, Minimal spanning trees, single-source shortes paths, all pairs shortest paths, maximum flow

  Part VII: sorting networks, arithmatic circuits, algorithms for parallel computers, matrix operations, polynomials and fft, number theoretic algorithms, string matching, computational geometry, NP-completeness, Approximation algorithms.
  
  

• Review of Introduction to Algorithms by Cormen and Others

  
  By A2V9H3ITX80FAX on 2006-02-06
  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.
  
  
• What every computer scientist should have
  By A14FXEKB1PXTZG on 2001-01-18
  If one were to make a list of the 100 best books in computer science, then winnow that list down to 10 books, and then again down to 1 book, surely this would be that book.

  Known in computer science circles as CLR (for the authors) or simply, "The White Book", Introduction to Algorithms by Cormen, Leiserson, and Rivest is the de-facto standard text for algorithms and data structures. It covers all the basic subjects (big-O notation, trees, graphs, etc...) as well as a few intermediate subjects (amortized analysis, matroids, etc...). Of course, this book is not the be-all and end-all of computer science nor does it pretend to be. It touches on NP-completeness only lightly and all but omits randomization; but if you wanted a text on NP-completeness, you would be reading Garey & Johnson and if you wanted randomization you'd go to Motwani & Raghavan. But if you need a reference on data structures and algorithms, this is the book for you.

  Now, some have complained that while this book is an excellent reference that it is a poor text to learn from. I beg to differ. I concede that it is certainly more demanding than many other introductory texts, but this is a boon not a curse. By remaining true to computer science's mathematical heritage, Cormen et al. force the reader to become accustomed to rigourous, formal reasoning, something which is unfortunately absent in many computer science curricula. The authors present the concepts cleanly and clearly, without the distraction of any specific programming language/paradigm. Perhaps it is this removal from a familiar C/C++/Java/flavour-of-the-month/etc... milieu which makes some readers nervous. But it is precisely this separation which forces the reader up into the realm of abstraction where computer science truly resides.
  
  

• The best textbook I have ever seen
  By AWBMOOKF7C33D on 2000-01-08
  I was the instructor for a junior/senior course on Algorithms at the University of Southern California and I used this book as the textbook. Unfortunately, many of the students didn't like this book because they did not appreciate the mathematical flavor of the book. A course on Algorithms is useless without a sound background in discrete mathematics. Hence, this book assumes that you are reasonably strong in Discrete Mathematics.

  I haven't seen a better textbook ! Here are some reasons:

  1. The discrete mathematics foundations are present in the first few chapters of this book and so, you can quickly brush up on any discrete math background that you may require while using this book.

  2. The style of writing is very light and at the same time, rigorous - almost as if you are in the middle of a lecture while reading the book.

  3. The material is comprehensive and serves as an excellent reference for other courses and in your future career.

  4. The exercises and problems provide a very good learning experience.

  5. It's a good-looking book !
  
  

• Rigorous coverage of the most widely used algorithms
  By A39S5NUJGUHV34 on 1999-12-05
  I personally bought this book in preparation for the International Olympiad in Informatics (IOI), and it helped me immensely in getting off the ground with the algorithms I had to learn, especially the chapter on Dynamic Programming. Since then, however it has remained a priceless companion during my studies and at home.

  This is the definitive reference for algorithms with a firm theoretical and mathematical foundation. Algorithms are treated with a thorough theoretical introduction often with a complete mathematical walkthrough, a clearly thought out solution, a discussion of its pros and cons, lots of clear and consisive diagrams, a pseudocode implementation, and a good deal of serious optimisation discussion. It's written in an accessible manner, starting with the elementary issues, progressing to the advanced and complex thinking needed to conquer them, so you'll find you have to give it your full concentration.

  This book will not disappoint. Its explanations are rigorous and its coverage spans all the general purpose algorithms with little focus on their applications but rather on the algorithms themselves. The book covers such major areas as sorting, data structures, advanced design and analysis techniques, graphs, each about a hundred pages on average, and a selection of specialised algorithms such as parallel programming, string matching and computational geometry. Because these algorithms are used everywhere, from games, graphics and simulations to electrical engineering it will have a broad audience and will find a home almost anywhere there is serious programming involved. Each chapter is a unit in itself which means you don't need to read it cover to cover, since they all start off smoothly and handhold you through. Clearly written by professionals, this is the book I know contains the information that I can't find elsewhere.
  
  

• Honestly? I'm disappointed with reviewers...
  By A370O39F15GK89 on 2004-03-13
  Giving this book a bad review because:
  a) you had a bad instructor for the course
  b) you find the material difficult
  c) you can't understand pseudo-code

  are not what I would call constructive or worthwhile critiques of the text of this excellent book. PLEASE society, PLEASE understand that some topics you have to actually WORK at understanding. It won't be spoon fed to you.

  It seems moreso with Computer Science majors than other majors (I'm an electrical engineer undergrad, comp sci grad student) that they whine and whine and whine about the math or about it being difficult to actually have to work to understand something.

  Oh my GOODNESS!!!! It's hard? Well, BLAME THE BOOK.

  Rant over.

  This book is amazing. It's the bible of algorithms and, to some extent, data structures. If you're not aforementioned whiners, feel free to buy this book, work hard, and learn a lot! There's not a better book out there in my experience.
  
  

• The worst text I have ever seen
  By A3AB3BOFIMPRSW on 2004-09-14
  In my 20 years in the computer industry I have seen a lot of textbooks.
  This text is by far the worst book I have ever seen on any subject.
  
  1) The psuedo code is worthless unless you are very familiar with the dead language APL. Why not use a language that some of the readers might have actually seen before?
  
  2) The explanations seem intentionally convoluted. The author is more interested in trying to show how smart he is instead of helping the reader to understand the material. He skips numerous mathematical steps in almost every example. Giving the impression of finding the results by magic. The reader should not be forced to figure out the procedure by trial and error.
  
  3) There are no answers to any of the exercises. The arrogance this displays is truly astounding. Does the author truly believe that the problems are so trivial that the answers are self-evident? If they were trivial then there would be no need for a text at all, we could just absorb the knowledge from the ether as the author seem to think we can.
  
  4) The author never shows the reader how to put any of the algorithms to any practical use.
  
  Here's the test for a good book. Can a person of reasonable intelligence, given this book, and enough time, learn the material unassisted? If the answer is no, then the author failed to do his job.
  
  
• The definitive reference for data structures and algorithms
  By A2TZ6DETANJ80Q on 2003-02-02
  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.
  
  
• A student's perspective -- this book is horrible
  By on 2001-11-08
  I don't know who is paying the other critics to give this book a high rating but this book has a lot of problems. There is an insufficient number of sample problems with answers, which is a minimum requirement for any math book. The questions at the end of each chapter are not related to the examples described within the chapters. It can take hours to frame a problem and even then you are not sure if your answers are correct because you have no way to check your work. "We will leave that as an excersise for the student" -- what a cop out.

  The sad part is that the material should not be impossible to learn. The authors have managed to take a difficult subject and make it worse. You know you are in trouble when your professor is also struggling with the material in the book. Whatever happened to "reaching the students".
  
  

• The New Edition is Great!
  By A29SEF2BOA0MXE on 2002-01-22
  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.
  
  

• Badly written, typical MIT book
  By on 2001-06-04
  Extremely thorough and pedantic but simply bad as a teacher. It does a bad job of explaining even simple algorithms, and in typical MIT style pompously views its subject like some sacred art. There is a huge amount of material here, much of which is off the subject of algorithms, and they think they are being clever calling it "an introduction". Some people might love such a mathematical monolith but it doesn't pay attention to the reader and instead becomes a pompous load of maths that lacks local coherence. As a reference it is useless because there is virtually no layout.
  
  
• Great Book
  By ACZDW7XSL647U on 2000-09-17
  I would just like to add a couple points to the review of this book here. First, it is a great introduction to the theoretical foundation of algorithms and computation, and it is not your average algorithm cook book. For that, you can find numerous books on various topics, such as "Algorithms in C" or "Numerical Recipes." Second, the assertion that it is processing power, not code optimization that reigns these days is simply missing the point. It is first of all not true, (just ask any programmers working on games, or serious business processing, or databases, or networks -- you name it -- code optimization is as important as ever; maybe your run of the mill GUI front end needs no optimization, but you wouldn't care about algorithms there anyway). And if you read the book, you will know that a lot of important problems only have exponetial solutions, and exponetial growth in hardware power (aka Moore's law) has a physical limitation. Therefore don't expect improvment in Intel chips to compensate for all of your bad programming. Third, this book pretty much only deals with asymptotic behaviors of algorithms. If you want to learn code optimization, it's by far not enough. You have to optimize the code behavior in each iterative cycle as well, such as reducing the number of comparisons, reducing memory references, reducing floating point multiplications and division etc. However, there seems to be no book on how to reduce such "constants" in algorithms. "Real-world" optimized code often involve techniques that's system dependent, or that uses information/boundary conditions that are not part of the general problem etc. There is no better teacher other than reading some good code or having a discussion with the field warriors - good programmers around you.

  In summary, for its purpose - a relatively theoretical treatment of basic algorithms, this book is the best I have seen.
  
  

• Great book with one major shortcoming
  By A2CLNUX7JXQJAQ on 2007-02-11
  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.
  
  
• More Suitable for Math Majors than CS Students
  By on 1999-12-22
  If you're not very strong in math, take the advice of the reviewer who recommended a companion textbook on Summations and Logarithms. Much of the text and exercises revolve around proofs that might be easily understandable to math majors, but very hard to follow for me (CS major). I would prefer to have more diagrams and less mathematical formulas.
  
  
• Complete, but examples are poor
  By on 2000-08-18
  I used this book for an Algorithms and Analysis course. While the book does present several interesting algorithms and is very complete, it has some major problems as well, namely with the examples. The book breaks a few of the standard rules I've learned in all other computer science courses. Every other CS course I've has emphasizes that computer scientists count from 0, not 1, when using loop control variables. However, this book ignores that practice and counts from 1. Also, every other CS course has emphasized using descriptive variable names. The pseudocode examples in this book almost always use single letters as names. These two issues combined make the examples clumsy; the reader often has to spend more time figuring out what the variable names mean and adjusting intuitive loop counting than understand how the algorithms work. This book contains a great deal of useful information, but it could be presented more clearly.
  
  
• Concise and Clear, No. Why not both?
  By AP3QVBHMJIGK7 on 2004-06-21
  There are a number of reviewers who proclaim that the language agnostic nature of this book, in addition to it's erudite tone, more than compensate for the (artificial) learning curve.

  I beg to differ. Being an actuary, I recognize that this book's code snippets are written in a variation of APL. APL is hardly a self-evident programming language (read-only is a more accurate description).

  While computer science cognoscenti might decry spoon-feeding, there's nothing wrong with being *concise and clear* concurrently. Indeed, the truly great books in the hard sciences are both easy to read and rigorous at the same time. If pedants would get off of their high horses for a moment, they would probably admit this much (heck, who wouldn't?).

  Rigor at the expense of clarity may appeal to intellectual snobs (who live for the material, god help them), and clarity at the expense of rigor may appeal to beginners, but WHY NOT HAVE BOTH?

  While this book covers a good deal of ground, it does so at the expense of clarity. A canonical book would have both rigor and clarity, and this book doesn't. It's as simple as that.

  The sordid truth about this book is that Professors tend to assign it as reading material with the expectation that students will rely primarily on class notes and then use the book as a reference of sorts (or as a source of homework problems). Most of the graduate courses that I've taken follow this approach.

  Having said all this, academia is essentially a small and sterile refuge for people who couldn't hack the real world. Take your courses, if you must, and then go out and get a life. In the end, most journals end up in the waste basket. Your time on this planet is short, don't waste it cloistered in a library!

  trust me on this...
  
  

• Poorly written with lack of ways to test yourself
  By A17A0MOQFK9K1D on 2004-04-20
  While many have noted how Thomas Corwen and his co-authors have added a scholarly touch to this subject with plenty of proofs it does not make for a good text. One can argue that this book should supplement the instructor's teachings. That would be fine except for the fact that there are no answers to the problems. Therefore, a student has no idea if he or she is on the right track.
  To this end Corwen snidely replies on his website that any student asking for the answer will have his or her name posted as a potential cheater since Corwen believes that instructors should be able to use his problems as homework. Here's an idea, how about instructors developing their own problems!
  Corwen also does not relate the material in plain English as someone like Frank Carrano does. There are other sources of many of the concepts like binary search trees, sorting algorithms, O-notation. The only thing Corwen is adding is lots of proof and mathematical shorthand.
  If you are interested in the mathematical concepts behind the algorithms this is a fine introduction. If you are interested in the algorithmic concepts, this is not for you. Ultimately if you are a student whose instructor will be using this book, you have no choice about buying it. If you are an instructor, however, look at another book to supplement your teachings.
  
  
• Overhyped garbage
  By A2VZYN6SNXMYH2 on 2006-02-04
  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.
  
  
• Great reference, Bad textbook
  By A2RNMSNX5Y5J3T on 2006-10-03
  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.
  
  
• THE book for learning the practice and theory of algorithms
  By A2E3F04ZK7FG66 on 2006-02-01
  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
  
  
• Slightly more fun than the dentist, but not much.
  By A6CMYV2RPOUA6 on 2002-04-11
  As textbooks go, this one is pretty dry. Granted, it is about Algorithm analysis, but even so, its pretty bad. The explanation of the concepts is poor, and the exercises are not obviously answered in the text, if they are at all. This book is known to actually introduce concepts in the exercises at the end of the chapter. Question: what is X? Index says: see question on X. I have never had a worse text in my life. If you are a teacher, and hate your students, require this book. It more than any other will give your pupils ulcers and sleepless nights.
  
  
• Theoretical Foundation
  By ACZDW7XSL647U on 2000-09-17
  I would just like to add a couple points to the review of this book here. First, it is a great introduction to the theoretical foundation of algorithms and computation, and it is not your average algorithm cook book. For that, you can find numerous books on various topics, such as "Algorithms in C" or "Numerical Recipes." Second, the assertion that it is processing power, not code optimization that reigns these days is simply missing the point. It is first of all not true, (just ask any programmers working on games, or serious business processing, or databases, or networks -- you name it -- code optimization is as important as ever; maybe your run of the mill GUI front end needs no optimization, but you wouldn't care about algorithms there anyway). And if you read the book, you will know that a lot of important problems only have exponetial solutions, and exponetial growth in hardware power (aka Moore's law) has a physical limitation. Therefore don't expect improvment in Intel chips to compensate for all of your bad programming. Third, this book pretty much only deals with asymptotic behaviors of algorithms. If you want to learn code optimization, it's by far not enough. You have to optimize the code behavior in each iterative cycle as well, such as reducing the number of comparisons, reducing memory references, reducing floating point multiplications and division etc. However, there seems to be no book on how to reduce such "constants" in algorithms. "Real-world" optimized code often involve techniques that's system dependent, or that uses information/boundary conditions that are not part of the general problem etc. There is no better teacher other than reading some good code or having a discussion with the field warriors - good programmers around you.

  In summary, for its purpose - a relatively theoretical treatment of basic algorithms, this book is the best I have seen.
  
  

• Useful overview
  By A3EQQP0LD4Z375 on 2001-06-22
  This book has served well the needs of many researchers, scientists, and software developers since it was first printed in 1990. The authors have done a first-class job, and no-doubt the book will continue to be a good source of information in the next decade. Pseudocode is used to illustrate how to eventually code the algorithms, and exercises abound throughout the book. It has been, and will continue to be used as an effective textbook.

  After a comprehensive overview of the mathematical foundations, the authors treat sorting algorithms, with heapsort, quicksort, and order statistics treated in great detail. They give an asymptotic analysis of the algorithms, and give an introduction to randomized algorithms in the discussion of quicksort. I found the discussion on order statistics very helpful for studying data polling algorithms in networks.

  The authors then discuss data structures and how they can be used to construct algorithms for different problems. Queues, stacks, linked lists, and trees are discussed in detail, and the authors give asymptotic analyses for hashing and searching algorithms. The very important area of dynamic programming is also discussed at length. From the standpoint of someone interested in network modeling, I found the discussion of Dijkstra's algorithm especially well written. Unfortunately, the authors do not discuss in detail the Ajtai-Komlos-Szemeredi sorting algorithm. The treatment of this algorithm in the original paper is difficult reading so a better presentation would have been nice here. Parallel algorithms are given a nice treatment. The Fast Fourier Transform is given an interesting application to O(n lgn) multiplication of polynomials.

  For readers interested in cryptography, the authors discuss the algorithm for the RSA cryptosystem. Primality testing is also treated, with the Miller-Rabin probabilistic algorithm given a nice treatment. The Pollard rho method for integer factorization is also discussed.

  I found the discussion of string matching also very useful from the standpoint of computational biology. The Rabin-Karp and Knuth-Morris-Pratt algorithms are both treated in great detail.

  A short but good introduction to algorithms in computational geometry, such as the gift-wrapping algorithm in convex geometry, is given.

  The authors thus cover a large amount of material here, and each chapter could itself be a 1000-page book. But their selection of algorithms in each of the areas covered serves well to introduce the reader to the more popular ones available. A large list of references is given for further reading on revisions and extensions to these algorithms.
  
  

• Introduction to Algorithms, Second Edition
  By A2L8IKVGAVA2HH on 2002-12-16
  Coinciding to a course i'm taking at University of Riverside I find this book to be include rigous reading. The word "Introduction" in the title is a misconception to the explantions and the wording within this book. The reading takes time to comprehend, and it seems to me there's more context than content. The "psuedo-code" provided is not desriptive as it should be. I find myself spending more time trying to understand the psuedocode rather than the concept itself. A great deal of explanations are expressed in mathmatics, and i've finished gone beyond the calculus series that are offered here and i find it hard to grasp certain concepts and i find myself using the calculator more than writing actual code. Another large drawback is the fact that the excercises at the end of the chapter do not have solutions... it's as bad as having a physics problem that blindly deals with the subjects within the chapter thwarted from and offer no solution. It's rediculous. For the other people say "yaye i tihnk this book is great," i find it hard to believe. The context is thick and clutter, the explantions are obscure and confusing, the math needs much understanding itself, and the exercises have no solutions. Terrible!
  
  
• This is the bible on algorithms.
  By AAP24L83AP0J3 on 2004-10-30
  I feel the only reason why this book gets any bad reviews is because the title "Introduction to Algorithms" is kind of misleading. The text is extremely technical, requires a pretty serious mathematical background, and is geared towards computer scientists, not programmers (yes, there is a huge difference).
  
  If you are a self taught programmer with no formal background in the field of computer science, this book is probably going to be way over you head.
  
  Regarding the pseudocode, it is pseudocode! It is not a real language. If you do not understand what pseudocode is, you need to go back to CS 101.
  
  About the book not providing answers to the exercises, I think this book is mainly used as a university text. Your professor should choose which exercises you should attempt and then go over the answers in class. It would be nice if maybe a seperate answer book was available.
  
  Now I'm not going to sit here and pretend that I understand even half of the book, but I do understand what the book is. It is a pretty standard text that very technically examines many computer algorithms.
  
  
• Amazing
  By on 2001-05-14
  I'll just start out by saying that this is probably the best computer science related book that I have read, and I've read a lot during by education and beyond. This book covers so many important data structures, algorithms, and concepts, and it does a great job with everything. Everything is easy to read and well-explained with just the right amount of illustrations and pseudocode examples. Each section and chapter also includes exercises which use information from the material very well.

  The size of this book and some of the topics might scare some people away, but I would recommend it for those new to algorighms and data structures,to those who may not be familiar with some of the concepts covered in the book, or to those who haven't and/or don't want to memorize all of the intricacies of, say, Fibonacci heaps.
  
  

• It's a standard, but...
  By on 2004-06-15
  I have deep respect for math and people who can make sense out of it, but I am really slow thinker and this book simply overwelmed me. I don't know what is so wrong with having some problems answered. I learned to solve them by going through step by step examples, which this book lacks. After "Single Variable Calculus" by Stewart and "Discrete Mathematics" by Epp, this book looks quite arrogant. Each page like a statement: "You stupid, don't touch me!" I did not like pseudo-code and I did not find it's clear and helpful. This book has a lot of good stuff, but I don't believe that making things hard makes them more important and full of sense. After all , I think everything can be divided into simple ideas , and then explained. Like those "divide and conquer" algorithms that authors describe. It's pitty that they themselves don't practice what they preach.

  Don't buy it unless you're forced. Get Robert Sedgewick's books. They balance well math and programming and have nicely done code snippets.
  
  

• Artificial Intelligence: A Modern Approach (2nd Edition) (Prentice Hall Series in Artificial Intelligence)
• Introduction to the Theory of Computation, Second Edition
• Operating System Concepts (7th Edition)
• Computer Organization and Design: The Hardware/Software Interface. Third Edition, Revised
• Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series)