Rating: 
Summary: The best 'single volume' on Algorithms
Review: One sure sign of a book's poularity is it being referred to by an abbreviation or a nickname. This book is known as 'CLR', so that tells you something. I called it the best 'single volume' in deference to Knuth's masterpieces in three volumes (with more planned!) - but if you want one book that provides a clear and rigorous presentation of data structures and algorithms that is optimum in both breadth as well as depth, then this is your book. As the backcover says, some books on data structres and algorithms are rigorous but leave out many topics (eg Aho et al's excellent book), while others cover masses of material at the expense of rigour and correctness. (too many examples of this kind :-) !! ) This book makes the tall claim of being both rigorous and comprehensive - and it **more than lives up to it**. This is not exactly meant for novices - but if you are comfortable with introductory college maths and have an analytical bent of mind, you should have little trouble following the material. Starting with some of the required mathematical background, the authors cover basic data structures and their algorithms, searching and sorting in great detail, followed by a treatment of graph algorithms. They then move to 'advanced algorithms', presenting an introduction to various specialsed fields, eg computational geometry, string algorithms, number-theoretic NP-completeness, and even Approximation algorithms. The clarity of exposition is the book's greatest strength, not to mention the encyclopedic scope and the powerful rigorous analysis. Another 'standout feature' are the illustrations, which will help clarify many concepts that words alone may not be able to. All algorithms are presented in pseudocode, which can be easily adapted to your favourite programming language. It is a great preparation for research in any field of computer science, and also an indispensable reference for anyone who does serious programming of any kind. If you have anything whatsoever to do with algorithms, this is **the** book.
Rating: 
Summary: Good Survey of Algorithms and Data Structures
Review: The CLR book is a good source of information about commonly used algorithms and data structures. It's not the be all end all in that regard, but for most purposes, it will probably have an efficient solution for your problem. By and large the material is presented in a clear and concise way, and their psuedocode is easily translated into whatever language you happen to be using. Note that this book is not for novices - it's fairly complex and assumes a good background both in programming and mathematics. Also, while the text makes a very good reference, it is also a text book, so it does pose some questions that it doesn't answer completely, or at all. It's quite a task to read through this book cover to cover, but doing so is well worth the effort.
Rating:
Summary: The bible on algorithms and data structures
Review: I had to buy a copy of this book for my first year Algorithm & Data Stucture classes at University and I've had it in a treasured spot on one of my bookshelves ever since. All introductory information on the most important algorithms and data structures that have come out of computer science in the couple of decades since its beginnings are in here. It can be easily used as a learning text book and afterwards as a valued reference volume. Anyone who has anything to do with software development should own at least one book covering about the same ground as this book does, and at the level of rigor and completeness of this particular one, why not let this be the one you buy? You won't regret it.
Rating:
Summary: Useful overview
Review: 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.
Rating: 
Summary: Badly written, typical MIT book
Review: 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.
Rating:
Summary: A good workbook for fundamental of algorithms
Review: This is great book. It contains allmost all of classical algorithm theory. It is one of most complete book from this field. Some advanced fields of algorithm theory are not explained very well, such as randomized algorithms, which are explained in only one example; average time complexity and average time good algorithms; maybe genetic algorithms etc. I'm highly recommend this book for learning fundamentals of algorithms.
Rating:
Summary: Excellent book
Review: This book is an excellent reference/guide to many common data structures, as well as other odds and ends. Great stuff!
Rating:
Summary: complete but lack of examples
Review: This book is by far the most complete one I have ever seen. It covers wide variety of algorithms and data stuctures used in computer science field. Only drawback is that it does not have lots of examples.
Rating:
Summary: A Very Solid Introduction to Algorithms
Review: 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.
Rating:
Summary: Extremely good
Review: Well, as a preparing-for-national-and-if-God-helps-international-computer-olympiads highschool student, I found this book not only useful, but neccesary. First of all, I have to say that I owe a Romaninan (by the way, who was #2 at the IOI 2K?) translated version of the book. No matter, the information inside is invaluable, and I recommend it to anyone who wants in-depth information about all of the fundamental things that computer programming goes about. I especially liked the chapters about Trees and Graphs. If you don't owe a copy of ths book, you don't deserve to call yourself a computer programmer :)
| 
