[...]I have at least half of both volumes, and it really seems to me that there are real problems here with the exposition. Let me see if I can elaborate.

Here is an actual sentence from the book-

We construct a symbol table that is made up of an ordered array of keys, except that we keep in that array not the key, but an index into the text string that points to the first character of the key.

Consider that there are two possible conflicting meanings of the sentence fragment :

...an index into the text string that points to the first character of the key.

In the first meaning, there is an index that points to the first character of a string which string has the property that it, in its turn "points to the first character of the key". (a String is engaged in pointing and so in the index.)

In the second meaning, there is an index that points (into) a text string and in fact that index points into the FIRST CHARACTER of that text string, and that first character the index is pointing to, well, that is the also first character of the key. (only the index is pointing; the string pointeth not.)

OK so how do you describe what's missing here? At least the disambiguating use of commas, at least. It's as though he likes to write in subordinate clauses, but thinks it's economical to leave out the punctuation (which, it is true, there are no hard and fast rules for).

So it's just sentence after sentence after sentence like that. Sometimes you can understand what he's saying. Other times, really you just can't. IF each sentence has 2 (or more!) possible interpretations, and each sentence depends on your understanding the last (as is the case- he never says the same thing in two different ways), then you get this ambiguity growing at the alarming rate of x^2, an observation the author might enjoy.

As the other reviewers said, the code is a C programmers attempt to write in Java. This never goes well.....


But the fact remains it is still the most accessible and thorough coverage of some of its subjects. So what are you going to do?

I don't get the impression he is deliberately bartering in obscuratism, it's just that this book suffers (and so will you) from a lack of editing, a lack of reviewing and feedback by genuine, unaided learners etc. etc.

You might want to check other people's lists for alternatives. Or not. Perhaps that passage was perfectly clear to you.

Another reviewer gave this book a one star rating citing that the book falls short on practical examples.

In light of that, I'm concerned that other readers might overlook what, in my opinion, may be one of the most comprehensive and well written introductions to graph theory and graph algorithms that there is, and certainly one of the best that I have personally come across thus far.

Recently I took on a project wherein I needed to solve a shortest path problem for a particular kind of graph. I am not a specialist in graph theory and needed practical information that I could utilize immediately. For me, this book fit the bill and was a godsend.

It is true that I already had a practical real world application in mind before I even knew of this book but this book has exceeded both my needs and expectations.

It is easy for me to understand how you may not initially see the practical value of the information being presented, if the sole reason you're studying this book is simply because it is a part of your college curriculum. I think, however, that that does not lessen the value of the book, especially for those of us who do have practical applications for the material.

If you are looking for an informational resource for a real-world problem related to graph theory, you would do well to consider this book.

The book does actually open by citing several practical examples of areas where these algorithms can be applied, although, perhaps the reader who assigned the one star rating may have appreciated and benefited from a case study.

I have the dubious distinction of having taken a class that used this book as it's central text. The illustrations are great. The explanations of algorithms and general algorithm design concepts are clear. The code, however, is neigh unreadable in a lot of places.

This was a huge problem for me, as I had a lot of difficulty seeing a clear mapping from the concepts explained to the code examples. Sedgwick's code examples often build on previous ones to the degree that they are not understandable on their own (this is especially true with the graph algorithms in part 5). If you try to use this book as a reference you will find yourself digging much harder than you would like in order to understand code samples that are actually quite simple. You could see how this might make a programming based course difficult.

This is an excellent book. Robert does a great job leading you through the fundamentals of algorithms and algorithm analysis. The visualizations are very well done. In particular the sort algorithm coverage is very well illustrated and described.

The best parts of the book are sorting and searching. A wide variety of algorithms are explained and demonstrated in detail. The code is solid and the writing is very good.

This is the set of Java algorithms books.

After reading the glowing reviews from the other folk here, I was a little excited about this book. It was the text chosen by my college for a class in Algorithm Development. My excitement quickly turned to disdain after reading a few chapters. Theory and performance data are covered very extensively, and for that, I applaud the writers. But what is missing for me is practical examples of where you would use the algorithms presented! Try as I might, I couldn't find any real-world examples for any of the algorithms. Maybe I learn differently than everybody else, but examples go a LONG way in helping me understand things.