Introduction to Algorithms

Rating:
Summary: My personal library about Algorithms and Data Structures
Review: "Algorithms and Data Structures" is a huge field.
Lot of algorithms and data structures are used in todays computer software of variuos types. Not all data structures or algorithms on them are adequate for solving a particular problem, so you must have some skills to say which one is "better" than another in your particular situation. Despite it's name, this book is an almost complete reference to achieve this skills. Sure, material presented here is not so easy and the book is not something you can read while watching MTV. Each chapter presents an argument in a very concise and formal way. Too much for some people, but this is not bad. Just skipping what you don't/want understand is the primary key to appreciate this book. When you will master the main concepts of the argument you are interested, it's a pleasure returning on those parts you have precedently skipped.
Parts about sorting and selections (heapsort, quicksort, linear sorting, etc.), common data structures (stacks and queues, hash tables, search binary trees, red-black trees), advanced data structures (B trees, binomial heaps, Fibonacci's heaps etc.) and algorithms on graphs (depth first traversal, minimum set cover, Kruskal and Prim's algorithms, Bellman-Ford's method, Dijkstra's algorithm) are well written and you can consider this parts as a reference for the future.
But this book as bad things too. The pseudocode, even if comprehensible, is not so much readable. In some cases it's too much dependent by the contest and this increase your understanding time. Chapters about math reference are not clear at all. Too much arguments without too much explanations, especially sections about algorithm's analisys. The last part of this book about complements and extensions could be easily dropped off from the book. Material presented here don't fit in an introductory text about algorithms and needs other knowledge a person who is reading this book obviously don't has.
A note on what that particular data structure is useful for would be very appreciated. Good book. Well spent money.

Rating:
Summary: Not easy to understand
Review: Although there is some great analysis of algorithms in this text, the text does not do a very good job of TEACHING one how to perform the analysis. I really did not like the fact that answers to the exercises are not available anywhere. I learn best by seeing examples done step by step and this book does not provide any solutions or even offer a separate solutions text. The authors seem to feel that the instructor should provide solutions, well I don't know about other Universities, but my professor does not provide solutions in class and the TAs are not very strong with this type of difficult material. Which leaves me to scour the Internet and other texts to try and understand the topics when I could have gained the same understanding by examining the solutions to the exercises.

Rating:
Summary: Honestly? I'm disappointed with reviewers...
Review: 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.

Rating:
Summary: No, the pseudocode is not APL
Review: I am one of the authors of this book. I read the reviews on occasion, and I have refrained on commenting on them--until now.

Two recent reviews claim that the pseudocode is APL. That is incorrect. The pseudocode is not APL. It is not even close to APL. The only reason I can even imagine that one might think that it's APL is that we use a left arrow for assignment, as APL does. I have actually written quite a bit of APL code in my time, and I know for a fact that our pseudocode is not APL.

I grant that not everyone likes our pseudocode. That is a matter of taste, and I will not deny anyone their opinion. Similarly, there have been other complaints that are matters of opinion, and I have no issue with people posting their opinions.

But get your facts right. To those who think that our pseudocode is APL: You are way off the mark.

For those of you who prefer your algorithms expressed in a real, runnable programming language, please note that McGraw-Hill offers a version of the book that comes with a CD containing complete Java implementations of all the algorithms in Parts I through VI.

(By the way, I wanted to leave the number of stars blank in this review, but the Amazon software demands that I give it 1 to 5 stars. So I'm entering my opinion, which is 5 stars. I admit to just a hint of bias.)

Rating:
Summary: This is the bible on algorithms.
Review: 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.

Rating:
Summary: Rigorous coverage of the most widely used algorithms
Review: 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.

Rating:
Summary: Great Book
Review: 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.

Rating:
Summary: The worst text I have ever seen
Review: 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.

Rating:
Summary: A definitive guide, but not perfect
Review: 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.

Rating:
Summary: Concise and Clear, No. Why not both?
Review: 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...