Customer Reviews

Algorithms in C, Parts 1-4: Fundamentals, Data Structures, Sorting, Searching (3rd Edition) (Pts. 1-4)

5 star:		(6)
4 star:		(4)
3 star:		(3)
2 star:		(5)
1 star:		(3)

 

 

Prof. Sedgewick is a noted authority on searching and sorting algorithms, and a former student of Knuth's. The text is authoritative, lucid, and detailed. It is also full of mistakes, poorly edited, and much of the code has serious and not so serious bugs.

I have the second, corrected printing of this edition. If you purchase this book, consider buying Bently's "Programming Perls" or some other book on debugging software, and consider Sedgewick's book to be an excellent opportunity to debug a standard reference in CS. In addition to scrutinizing the source code, don't accept any statement in Sedgewick unequivocally. Even his formula for computing the variance of a distribution is incorrect (the accompanying code is correct, though it magnifies the roundoff error; read "Numerical Recipies in C" by Press et al for a more civilized calculation). Many of his proofs have off by one errors, he misdefines the "transitive" property as "associative". Get the lastest printing available, eventually enough students and instructors will have gone through this book to ferret out most of its errors. There are no giant lapses in reasoning, and once it makes it out of beta, this should be a very fine book.

A much better investment would be "Introduction to Algorithms" by Cormen, Lieserson, Rivest, a vastly superior and more interesting text. It has far greater scope of coverage on the subject of algorithms, and is both clearer and more carefully written, one of the most illuminating books I've read. However, volume 1 of Sedgewick, as it focuses solely on searching and sorting, covers these areas in greater depth, and discusses practical implementation issues, such as sentinels and hybrid sorts. As such, Sedgewick is a good compliment to CLR. Bear in mind that it is more densely written than CLR, and hence requires a more careful reading.

There are many books about algorithms, just a few can impress and influence people acting on the very threshold between theoretical research and development of complex software. Robert Sedgewick codes very carefully. Some readers might even fail to recognize the fine details in his code. Try to analyse even the simplest 2-3 liners. Compare the program 4.5 (Linked list implementation of a pushdown stack) or 4.10 (FIFO queue linked list implementation) to similar examples given by lesser authors, figure out the the percentage of redundant code given by others compared to this examples (it is 50% to 300% faster for this elementary cases!).

Another example: Look at the insertion sort with a sentinel. I am not aware of any other book showing this simple improvement. Also none of the insertion sorts which I saw in the practice use this so tiny add-on sentinel to achieve the quite dramatic speedup of the process.

Naturally, in the time of 700MHz processors here and there a couple of extra instructions might appear unimportant, but I disagree. This is a book showing the basic algorithmics and programming practices in their best, down to the "two liners", regardless what the complexity of the task is. These little "pearls" of coding are in the real world running countless times behind the scenes and are important. Look carefully, learn, master to code as he does!

As a very modern text, this is one of the few books dealing at least with some of the newer algorithms, like the skip lists or sorting networks. Not enough, though. Maybe we will see more in the next volume. There are also some omitions of the basic algorithms, which I would expect to be in such a book. See the rather terse chapter 7.8 about selection methods and look into Cormen, Leiserson, Rivest to see what I mean.

Despite such complaints, in my eyes this book occupies the worlds top-level rank among texts about algorithms for people who really make software and not just call library functions. I cannot wait to get my hands on the next volume being in preparation.

My (standard) point of criticism is that too many exercises are without answers and actually some of them are so complex that a nice chapter with yet some more algorithms would be in place. But almost every book about algorithms has this fault. On the end of a chapter you often see: Improve this, solve that. Its not good enough for a practitioner but it serves purpose for students.

Extraordinary are the illustrations of algorithm visualizations which I like so much in this book.

My tribut to the author to NOT to use the questionable quotes of famous people on the begin of each chapter, as it lately became an annoying habit. One of the worse examples of such a quote were the alleged words of Albert Einstein "make it as simple as possible but not simpler" placed in an book about C++ (what is a contradiction in itself and quite a presumption on authors part putting himself on a pedestal with... Einstein.)

But exactly such a quote might almost be applied to this text. Congratulations Mr. Sedgewick!

I have decided that authors that are not willing to provide detailed solutions to at least the odd-numbered exercises are not worth reading. Why? Because first, where is the evidence that they know the answers to the exercises they present? But more importantly, how is the reader supposed to actually learn from the exercises if he can't see at least one possible solution and the rationale for that solution? This is the same reason why the Deitel & Deitel books are unacceptable. This isn't college anymore. Let's have some answers...if we knew how to do all this stuff already, we wouldn't need the book!

If you purchase this book as I did then be prepared to expend quite a lot of energy to derive any useful learning from this text. I am in full agreement with many of the other reviewers here as to the quality of this book. And I am not just referring to the numerous glaring typos and off-by-one errors but what seems to be a fundamental inability of this author to be able to explain himself in a clear, coherent manner. I do not expect the quality or caliber of say a "Richard Stevens", on every technical publication but this work is below par from what one would expect from a "professor". I have read many technical books over the years, on protocols, programming languages and data structures and algorithms. Reading through the text, and for books like this, compiling and running the examples, is par for the course. You learn by doing not just by reading alone. But a balance should be maintained.

It does have some redeeming qualities. It does cover a fair amount of material about algorithms. It does offer insight not available elsewhere (at least not in book form). But this is not a reference work you can look at while coding at work and pull some algorithm out of that you forget the details about.

Some say this work is densely populated. I believe this to be a misunderstanding. This book is terse in some respects and filled with circumlocutions in other places. An example of a dense, and yet clear and concise technical book would be "The Annotated C++ Reference Manual".

The author leaves out so many fundamental and subtle points regarding the subject matter that no student could hope to come away with a thorough understanding -- unless of course you perform the following:

type_the_examples();

for (i = 0; i < MaxTimesBeforeBecomingFrustrated; i++)
{
study_section_of_text();

for(j = 0; j < RunTimesBeforeYouForgetWhatYouWereStudying; j++)
{
run_code();
examine_output();
analyze_program_source();
fix_errors_and_assumptions_from_text();
compile();
}
}


Assumptions are made with the code examples that require careful attention on the readers part or you WILL end up with Segmentation faults.

The book does provide the material needed to form a basis in exploring ideas in the covered algorithms. But I found that I had to read through the code examples and run the examples to be able to meaningfully interpret what the text was stating. The examples usually form a basis for reinforcing the reader's understanding of the text but with this book this paradigm is inverted; without the code examples it would be futile.

The author mentions, justifiably so, that changing the input data would change the runtime characteristics of some particular program. Well, try this with numerous examples in the text and you will demonstrate first hand not how the performance might change but just how fragile the code is as witnessed by your accompanying seg fault.

In the end, you can learn from this text but it requires a great deal of work, and quite a lot of debugging; more so that what is normally necessary. Learning any technical matter is work for the most part but learning from this text is, in my experience not enjoyable work. The above issues end up distracting the reader from being able to focus on learning the algorithms which is supposedly the reason you bought the book in the first place. My fear is that any young reader (all but the most ardent), who picks up this book as his/her first book on Algorithms will be turned off from Computer Science for good. We have enough of those books already.

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.

...that is as relevant today as when it was first written.

As a computer scientist for 20 years, few books have had as long lasting an impact as this book. What has always amazed me is that once you've worked your way through an algorithm, and Sedgewick's explanation, you remember it. For me, it was, and still is, a foundation of computer science and as ready a reference today.

Really liked the writing style, Sedgewick does a good job of keeping the explanation human-friendly. Face it, it's a book on algorithms, not quite a summer reading beach book. :-)

All told, I put this book up with the Knuth series...btw, Sedgewick was a student of Knuth's.

Enjoy, and hope it helps out as it did me.

It's a great book. Things are explained fine and it is usable in practice too. But take care, it is just the first 4 parts. Graphical algorithms are not included and I wanted to take a look at those.

I read this book a few years ago and I found the algorithms for sorting and searching to be a very interesting. The chapters which contained descriptions of fundamental data structures were also very interesting.

This is one of the best book that I have ever read. The writer explained data stucture in a very good detail.
However, this is NOT a book for those beginers, writer assumed that readers must have some strong background in both C programming and math. As many C code functions are left out.
There is a clear difference between IT and computer science, if you just make web pages, click mouse in windows, know a little bit about programming, you will find this is a book hard to read and follow. On the other hand if you are computer scientist, digging underground understanding of lists, tree, pattern matching. This book is, undoubtedly the one to go.

I have always counted on Sedgewick for the best DS&A books. My older copy is so thumbed that I can find sections just by marks on the side. In this new edition the book has been updated - seems a bit easier to dig through - and some mistakes were corrected (although some new one were inserted). Overall, the best on the block for DS&A.