Customer Reviews

Algorithms in C++ Part 5: Graph Algorithms (3rd Edition) (Pt.5)

5 star:		(12)
4 star:		(7)
3 star:		(9)
2 star:		(2)
1 star:		(5)

 

 

This is easily one of the leading texts on data structures and algorithms - a third edition has already been released (however, that is practically a new book ,so read on :-)...). Sedgewick is a student of the great Donald Knuth, and a leading researcher and authority in the field of Algorithmics.

'Pound for pound', this might be as good as Cormen et al's classic, which is the undisputed leader among introductory books on algorithms. However, this has two advantages over that book :

(1)Size : Weighing in at a lean 656 pages, this is almost 40% smaller than Cormen's classic, while providing approximately the same breadth. However, Cormen has the edge in depth, especially rigorous analysis of algorithms' performance.

(2)'Real' code : This book has code snippets in C++, as opposed to Cormen which has it in pseudocode.However, the code is far from 'ready to run' - it's just enough to give you an idea how to go about building your own code.

Another plus point is short and crisp chapters which can be easily 'digested' - average chapter size is only about 14 pages.

This book really covers a lot of topics - sorting, searching, parsing, computational geometry, graphs, fast fourier transforms, mathematical algorithms and much,much more.

It is written in a very readable style, and the illustrations are a big help, perhaps the best in a book of this kind. It would've benefitted from a few more exercises, brief solutions, and a little more rigour in performance analysis.

The code is excellent at one level, but it's actually excellent C code masquerading as C++ code, i believe.

If you have no problem with C, you should perhaps go for the C version of this book - the C code is reminiscent of Kernighan & Ritchie. Beautiful, elegant C code !!

If it's good C++ code that you're after, perhaps Mark Allen Weiss's book or Heileman's book might be a better choice. Also, the new (3rd) edition of this book has much better C++ code.

If you want more depth and rigour, and are willing to work a little harder, then Cormen's the way to go.

However, if you want a bit of everything in one compact book, then this is the best choice.

(Sedgewick's come up with a recent revision, but it's spread over several volumes - not sure whether that's a better choice, however the C++ code seems much better in that, with C++ consultancy by Chris Van Wyk, another student of the great Don Knuth)

Just wanted to let everyone know that the reviews here (till 6th March
2002 at any rate) are not of the book 'Algorithms in C++ part 5
graph algorithms' by Robert Sedgewick, but of the earlier edition of
his book on algorithms.

To get an idea of the book it's supposed to be about, please refer to
the review(s) on 'Algorithms in C part 5 graph algorithms', which i
expect to identical but for the code.

It'd be surprising indeed if the book isn't substantially better than
the reviews for the earlier book indicate ..........

The first volume, ie parts 1-4 are excellent - please refer to the
reviews on that, they're for the current edition :-)

I'm a learned industrial engineer in electronics but got into informatics right after my degree. So I never had a course on algorithmic and had to learn nearly everything by myself.

After some years of working in the field, I tought it was maybe time to get some background on the subject so I got this (now an outdated edition) of the book.

Well, it was the book it took the longest to me to finish in the informatics field.

The book explains a whole bunch of basic and more advanced general-purpose algorithms, and so has a good coverrage of the subject.

However, there are two problems with the book:

1) The coding style is very bad: the author likes to use global variables, and variable names are often very cryptic. Example:
* p = parent
* g = grandparent
* gg = greatgrandparent
* c = child
* x = current node
* y = temporary node
...

2) You cannot read this book's chapters in a random way: you have to follow the chapter ordering, because often knowledge of later chapters is based of knowledge of earlier chapters, and, because of the bad coding style you have to often remember the meaning of the cryptic variable names several chapters later when they are reused. If you're like me, you've forgotten the meaning, which means reread that damn chapter, which in turn can again be based on an earlier chapter. You get the picture why it took me so long?

It is strange to me why some people love this book so much. Admittedly, Sedgewick is very respected in his field and knows a lot about sorting algorithms, but his book is still dissapointing and very frustrating to read for a beginning computer science student. He seldom includes complete code in his examples, and where there is code, there are sometimes errors in the code.

This reviewer took Sedgewick's class at Princeton University where this book was the required text, and not only was the text poor, his lectures were terribly boring. He himself even recognized that there were errors in his book, and so he allowed his students and TA's to submit errors found in the book. At the end of the year, the list of references to mistakes in the book took up more than three pages.

This review is not the result of a student upset about his grade (an A is fine with me), but is rather an attempt to warn students about the potential pitfalls that may be encountered in reading Sedgewick's book. I suppose this could be a great book for an intermediate or advanced CS student who doesn't mind the sparse and sometimes erroneous code or the terse language used to describe fairly complex ideas. Also, there are some parts of the book that are well written and a pleasure to read. However, I would never recomend this book to anyone interested in learning algorithms for this first time without a fair amount of prior programming experience.

Bob once admitted that almost all the code is translated from Pascal. He does not have time to write the same code for various editions of his books and uses translator software...

I first read Sedgewick's Algorithms many years ago for a programming class in college. I was impressed at the time by it's clear presentation and thorough handling of the most fundamental data structures and algorithms. Queues, hash tables, various flavors of trees and graphs... it's all explained quite well in the text. The orginal edition had code examples in Pascal, and when I lost that copy, I decided to get the 'C++' version. The content is basically identical -- which is not necessarily a bad thing. Those looking for modern object-oriented code examples, however, will be dissapointed. Only the most minimal effort has been made to go from the original Pascal listings. It is really a matter of expectations. The code is not the most readable (many single letter variable names), but the true value of this book is the text, not the code.

The code isn't very easy to read (the only downfall), but it is efficient, and that's what I want.. Take the book Introduction to Algorithms, take out the math, squish it and you have Alg in C++. It's really C, not C++, code but `C++' isn't its real purpose, `Algorithms' is. If you want to learn a plethora of computer algorithms, this book will give it to you. Bottom line.

I don't intend to read this book from front to back (well maybe one day if I get really bored) but I think this book does a very good job explaining the algorithm without getting obsessed with overly formal mathematical games. In my opinion the graphs are the most important part of the series, since these are the algorithms and data structures that usually AREN'T included in a programming language's libraries; STL for example. You will find many of these topics in a mathematics and statistics program (how I first encountered them) so the book does get mathematical, but out of necessity.

4 out of 5 stars for sometimes being unclear.

The source codes was written in a precise condense way and are intelligible. The content was well arranged.

The algorithm descriptions are, for the most part, reasonably easy to follow. The diagrams help to give you a very intuitive "feel" of how each algorithm works, and how each compares to other similar algorithms. This is, without doubt, my favorite aspect of this book. Another thing I like is that it didn't read like your standard textbook; it was much less formal, which I found a refreshing change (I read it in college). On the minus side, the code was pretty much C plus classes. Switching from C to C++ really didn't add any value. The author chose to write the code to be as small and concise as reasonable in order to convey the structure of the algorithm in question. I think that he went too far towards this goal; the variable names are are far too short, leading to confusion in complicated algorithms, and very few in-line comments are used.

Bottom line: while it certainly is not a model of how to write well-designed C++, it accomplishes its goal very well: describing, comparing, and contrasting basic to intermediate frequently used algorithms in a very intuitive way.