Sorting and Searching Books

Excellent reference.

However, I didn't like the idea of using MIX assembly language. Book would have been more readable if examples were in plain english pseudocode (even better would be 'C'). At least second edition should have taken care of this aspect.

I also suggest books from Cormen & Sedgewick on same subject.

This book is bible of computer programming.

It contains most detailed explanation of searching and sorting methods I ever found in a book. Contains all internal sorting and searching and external sorting and searching algorithms.

The only drawback of the book is that all algorithms are written in MIX - some kind of assembler, and because of that they are hard to read.

I just bought the book I needed out of the set. I needed to build a database that did not use any commercial package (this gives full access and no royalties). This book saved my bacon. I almost did not buy it when all I saw in it was math. But I was desperate and it paid off. Turns out you could not explain it any other way. This book goes way beyond binary, and bubble sorts. I use it primarily for balanced trees. I may try some thing more exotic later. I can not tell you about the other volumes but this one will defiantly pay for it's self.

As a previous review said: "This is a book about the science of algorithms. Algorithms are either right or wrong."

Knuth uses the MIX programming language throughout, and if you hope to learn programming by reading this book, you should look elsewhere. Maybe someday we'll have 2^32 registers, but we will still be trying to make our programs work faster on this, as yet, uninvented architecture. The fundamental concepts will remain the same, and people will still be reading Knuth to understand them.

A good reference for serious computer science students. Others should look at O'Reilly. They have some really good books on visual basic.

This is an encyclopedia of what is known about sorting and searching and what computers can do. It is nothing else.

Graduate students in computer science (especially those in theory, algorithms and the occasional compiler fan) will benefit. Hackers and script kiddies will probably not benefit from this book.

First the basics: it's great, it provides wide-ranging and deep analysis, it shows many views and variants of each problem, and its bibliography is helpful, though not exhaustive. The historical notes, including sorts for drum storage, may seem quaint to modern readers. And sorting has been done, right? You just run a shell program or call a function, and tap into the best technology. Does it need to be done again?

Yes, if you're on the edge of technology, it does need to be done again, and again, and again. That's because technology keeps expanding, and violating old assumptions as it does. Memories got big enough that the million-record sort is now a yawn, where it used to be a journal article. But, at the same time, processor clocks got 100-1000x ahead of memory speeds. All of a sudden, those drum-based algorithms are worth another look, because yesteryear's drum:memory ratios are a lot like today's memory:cache ratios of size and speed - and who doesn't want a 100x speedup? Parallel processing is moving from the supercomputing elite into laptops, causing more tremors in the ground rules. GPU and reconfigurable computing also open whole new realms of pitfalls as well as opportunities.

Knuth points out that the analyses have beauty in themselves, for people with eyes to see it. His analyses also demonstrate techniques applicable way beyond the immediate discussion, too. Today, though, I have nasty problems in technologies that no one really knows how to handle very well. I have to go back and check all the assumptions again, since so many of them changed. If that's the kind of problem you have, too, then this is the place to start.

//wiredweird

This is by far one of the clearest most easily understandable studies of the complex topic of algorithm analysis and data structure analysis. The author, utlizing a practical approach, creates an easy to read experience, and a very enjoyable one. Overall, an excellent text, and I recommend it to anyone who has ever tried to figure out what the difference between a red-black tree and a binary search tree really was.

There are already a lot of wise words written about the contents of these books. Although it may seem a trivial point in comparison to the contents, I was disappointed that the paper envelope around the volumes where not folded correctly, that is, the texts are not in the middle. A jewel like these books should not be present on a bookshelf in such a sloppy condition.

Knuth talks about the applications into informatics of the theory number.
This book , written several years ago, is today the best about those facts. I have studied recently the random numbers and I have read the algebric theory of this book . It's interesting as a solutions of algebric equation must verify statistic conditions for effective randomness.

This was a requested gift for my son. He is quite pleased with the series. He says the books are concise and informative. A definite recommendation!

I bought the three volumes of this marvelous work in 2004.Three years later (2007) I haven't quite gotten over volume 1. Yes,the expression of concepts in the MIX machine language has tended to slow reading considerably and just when progress was being made,I encountered Fascicle 1 of volume 1 on MMIX,which I found much easier going. Other volumes I have visited as the need arose. This work is dense on content and enjoyable to read (at a pretty slow pace yes) and highly relevant to every computing problem I come across.While I may ultimately not read every page of the current three volumes,I am nevertheless looking forward to the fourth edition of this great work.

Not snob appeal. Yes, it's not a good first textbook. I taught freshman programming at Caltech for a few years, and I admit I didn't use Knuth to teach, in the sense that I didn't require the students to buy it, nor did I assign problems from it. But I *did* tell all my students to buy it (the box set) if they could afford it. And every now and then I did refer the students to look up some detail in Knuth that I felt our textbook (the also very excellent Aho, Hopcroft, and Ullman) had glossed over.

The reason is that when I prepared my notes, and when I went to class, I held a copy of Knuth in my hand. Full of post-its. It's not the best book for "learners" (i.e., beginners), but it's the ONLY book for the algorithm "pro". Sure, you can teach undergrads out of Sedgewick (Knuth's student by the way). But how do you make sure you're not missing something by using Sedgewick? By reading Knuth of course.

If I knew a bright high school student with an interest in computer programming, I'd get him the box set for Christmas. I have to admit I first ran into Knuth when I was a grade school student in the early 80s. There are lots of books in the library that a kid of say twelve just isn't interested in: whatever they are about is something that is just irrelevant and unknown. Not so with Knuth: I was programming BASIC on my C64 back then and knew what programming was. Knuth was downright scary. Here he is talking about simple things, and .... who would have known there would be so much to say about sorting???

about MIX: One day Knuth will be dead. Any programming language that existed during his lifetime will be dead. TeX will be at version pi(=4 atan 1). The Art of Computer Programming will still be relevant, most of it. This would not be the case if
the examples were coded in any "standard" programming language, with all the special-purpose things they all have (no not even if they were in Ruby on Rails!) With MIX, they will at least be in a programming notation as irrelevant then as it is now.

I have an anecdote... when I was a grad student a fellow grad student of mine had come up with a new cute algorithm using two priority queues to solve some problem in CAD. We did some literature searches.. could this be a new algorithm? Nothing came up. Search the web... nothing came up. Look in the standard books on CAD.. nothing came up. Time to publish?

Then I remembered I had a copy of Knuth (he didn't, as it's not fashionable to have forty-year-old books lying around if you're a CS grad student). Turns out the data structure and algorithm the fellow had come up with were described and analyzed in the answer to one of the exercises in Knuth's vol 3. As I recall it the exercise had difficulty level "30" (on Knuth's scale of 0-50).

I draw the conclusion that "active researchers" in a field that has anything to do with algorithms, who don't use Knuth, are at great risk of attracting ridicule for not having read up.

I re-read this book every now and then. Sometimes I read it in the bathroom. Even though I have read it several times, I always learn something new. Often on every page.

This book puts most of my college textbooks to shame. Not that they were bad, but really this is a step above. Sedgewick is a master at distilling difficult concepts into just a few lines of code, and then talking the reader through all of the implications of any design decision. For a professional who needs to reacquaint himself with the basic principles of algorithms, and needs some simple code to get started on coding a solution, this cannot be beat. While I am not in school anymore, I feel this can also be a great supplemental text for any serious Computer Science university student, although it's possible that the focus on C++ implementations may not be ideal for curricula where Java is the mainstay.

One of the factors that I did not see mentioned in other reviews is that Sedgewick's visual representations of the algorithms are phenomenal. In older algorithms textbooks, these have always been represented by small diagrams--if any--that show what happens when an algorithm is used to attack a small problem (say, a linked list with 10 nodes). This text shows a visual representation of those small cases, but then goes the extra mile to show visual representations of the same algorithm when scaled to a variety of massive inputs. These representations are a great tool for comparing the scalability of various algorithmic approaches against one another.

I purchased this book to refresh my memory on data structures with templates. It is well written in most spots and provides excellent examples. I would recommend this book to any intermediate c++ programmer who wishes to learn/relearn advanced data structures such as Linked Lists,Hash,QuickSort,etc....

This book is full of great information on C++ algorithms. There are many excellent examples, and the author presents the gammit as far as topics. They really open up your mind to possibilities. The reading at times is rough going, though (very dry). Sample code or examples to download may be found at the publisher's website instead of the one printed in the book.

If you're looking for an exhaustive, upto-date reference/textbook for
fundamental, searching and sorting algorithms, then this is one of
the very best available.

Sedgewick has split his popular book into two volumes, with Graph
algorithms being hifted to the second volume. Moreover, many advanced
topics like computational geometry, fft, number theoretic algorithms
etc, which were introduced in the previous edition, seem to be missing
now - so the breadth of coverage seems to have reduced, which is a pity.

However, the depth has increased instead - i doubt that even Knuth
covers more sorting algorithms ! In particular, there are several
recent algorithms and data structures which are treated in greater
detail here than by Knuth. Of course, Knuth analyses all the
algorithms he presents in rigorous and exhaustive detail, which
this book doesn't.

Moreover, the book has many new algorithms and presents the state of the
art in sorting and searching algorithms, giving it a distinct advantage
over the older books.

Sedgewick makes it very clear in the preface that the emphasis is on
the practical importance of the algorithms, so esoteric algorithms which
are important 'only in theory' may find no mention. Also the emphasis is
more on the design of algorithms than on their analysis.

The number of (exercise!!) problems has multiplied manifold in this edition
to become more than most competing textbooks. Problems are graded by
difficulty level to help you choose the ones relevant to your needs.

The exposition is clear and authoritative - Prof. Sedgewick is a leading
authority in the field of algorithms and a student of Donald Knuth.
He has a gift for making difficult concepts seem simple, and the great
illustrations in the book go a long way in explaining the behaviour of
the algorithms.

For the practising professional, this is an ideal reference, since it'll
help you select the best algorithm for your task without bogging you
down with heavy mathematics.

The reasearcher, on the other hand, may benefit by gaining unique insights
from a master of the area, while using other books for the detailed
analysis of algorithms, including prehaps Sedgewick's own book on the
analysis of algorithms(with Flajolet).

A caveat - the code may not be 'ready to run'. It's better not to rely
on this book to provide you with usable code - if that is what you want,
perhaps the books by Drozdek/Weiss/Heileman/Rowe might be better choices.

If you want C code rather than C++, then the C version of this book is
a good choice, since the code provided is of 'K & R' class and therefore
a delight to read.

Of course, if you're looking for a language independent coverage,
then 'Introduction to algorithms' by Cormen,Leiserson and Rivest is
possibly the best book which combines rigor with comprehensive coverage
of the most important algorithms. Look out for the newly released
second edition.

And if you want a more rigorous and equally exhaustive coverage of
sorting and searching, go for Knuth vol.3 - still the authoritative
reference, though it may require more hard work on the reader's part.

Otherwise, invest in this and you won't be disappointed.

When you are ready to take the bold step into algorithms, this book is a great second step. I say second step because I think it helps if you read "teach yourself algorithms in 21 days" before this book.

This book deals with a good number of algorithms and does not shy away from reasonable analysis. The book helped a lot when I was having problems with putting a good harsh function together.

The chapter on recursion is also very good too.

In order to write decent code you have to know about this difficult/painful subject and this book takes some of that pain away.

Great book on Datastructures. Much verbose than the other books. But the java example in this book are horrible, particularly the variables used. Just letters are used as variables, instead of appropriate names, making it very hard to follow the example.

So overall, I would suggest buying Adam Drozdek's algorithm book.

This series is a treasure to keep. The book is filled with great diagrams and very easy to understand language.

These text(s) do for the software engineer what Cormen's book does for the scientist. To be knowledgable with algorithms will greatly seperate you from a novice.

Very good examples and using Java is very smart because most OO programmers can easily understand the language (C# is practically identical).

For those who struggle with the Cormen book, (Like I did) it would do you well to get this book. You will refer to it time and time again in your career as a software developer while the Cormen book collects dust on the shelf.

First is Knuth, second is Corman that brings the art of algorithms closer to earth. Then is Sedgewick. This book provides very good balance between theory and practice and lets the practitioners know that programming is a bit more than just writing "if" and "for" and that the art of algorithms is not only art but also science. This book evolved from early editions (Algorithms in C, 1990) and keeps the standard. These two volumes is the must for every serious programmer.

Cons: Java code is a bit "C-ish" and makes it clear that it is easy to write C program in Java. In addition, section Geometric Algorithms from 1990 edition and other material following this section is missing in newer editions. Maybe this material will be included in Volume 3, that as rumor says, is in preparation.

This book is a total mess, I don't know if it's the author or the publisher but is written in a style that got me really frustrated.

The author has the bad habit of start explaining a thing a little bit (not enough to fully understand it) then say something like "we will cover this topic in depth in chapter 7", and you are in chapter 2. This sort of jump back and forth is completely frustrating, the book doesn't seem to have any kind of flow. The same technique is used inside a chapter too, you start reading about something then the author start diverging in the middle of the topic to come back after few pages.

The code samples are a total mess, it's just really bad. I mean common, read any introductory book in software development and you get warned in the first chapter not to name your variables i,j,v i1...just give them a meaningful name.
Every time I read sample code in this book I had to spent at least 20 minutes deciphering what the variables are suppose to be, why the author define variables that are not used at all or they don't have any kind of effect on the end result (yes, I did found a whole bunch of these). If you don't know Java or don't care to follow any of Java standards fine, write C code or something, at least I will be prepared to read obfuscated code.

I give this book 2 stars, it has after all a lot of information in it, even if it is scattered all over the place

The second text (Part 5 - graph algorithms) was a real suprise. I bought the set for the first book, because I couldn't find the first text by it self. To my suprise, Part 5 was excellent and help me solve an issue I've been dealing with for weeks. The books not only give good analysis of the algorithms, but also provide sample source code.

Sedgewick's books are now an essential part of my C programming reference library. I've referred to his books many times since I bought them. Unlike most technical references, these books are excellent, even if you aren't interested in C. Excellent texts.

I had to teach this subject and this book seemed the best of the bunch though still not ideal. Why does the author have to use meaningless variable names (i,j,k), do comments make the code run more slowly. My main criticism is the examples and I would recommend the author use professional coding practices, comment the code, use meaningful variable names and structure it for readability. Else recommended for this subject

I bought these two book for one reason: to get help implementing algorithms. Since there is lot of code in these books, I thought this would be a good pick. I was wrong. The author is consistently leaving out details vital to understanding the code. He also makes a big deal about abstract data types. This is gloriously of the case. If the readers are supposed to understand the code, transperency would be a more intelligent goal for the author. There are no comments in the code what so ever (yes, this is actually true, not even in the on-line code). The on-line code to this book is a total mess. You would be able to implement all the algorithms from scratch in less time than it would take you to try an piece together the code the author has left for you.
The pity is that there are very few other algorithm books that have real code. Demand a new edition from the author and don't by this one unless you can avoid it.

I have quite a few books on algorithms and C programming, and this probably takes the cake. Sedgewick writes clearer than perhaps anyone on the subject. The book is filled to the gills with tiny 20 line (complete) programs that do amazing things - such as the program to compute all the prime numbers less than N (provided as input). These examples are typically given to illustrate some point (such as using dynamic array allocation for storing which numbers are prime) - but the short, concise algorithms given in the examples are learning aids as well (i.e. - I didn't know you could calculate a list of primes so easily, and I can probably take this knowledge and use it somewhere else). The reader is challenged to alter the examples (instead of using an array to store which numbers are prime, use a bitmap). Because the examples are small, compact, and easy to read, this provokes one to actually sit down and try and play with them. In contrast, I also have the Algorithms In C O'Reilley book by Kyle Loudon and after reading the Sedgewick title, I'm throwing that away. That book spends 1/3 of the chapter describing the algorithms, and then spends the rest of it in user-interface code examples. Of course, all the user interfaces for all the examples in the book are pretty much the same, so the whole book is filled with redundant useless code. More analysis, less filler, please. As Sedgewick was a student of Knuth, I consider his books as the practical guide to Knuth's tomes (which seem out of date - do we really need algorithm analysis on external storage these days??), which are filled with rigorous mathematical analysis. I highly recommend this book(s) -- actually there are two, with the second volume covering graphs. I wish my University had used these texts in programming / algorithm analysis courses. I really don't have any negative commentary -- other than the nitpick that his coding style is very compact and skeletal --> main(){ for(...) do_something;} However, since the examples are so small, it hardly matters.

Sedgewick's 'Algorithms in C' is undeniably the best book for beginners studying about algorithms and data structures. The text is clear, lucid, and the programming examples are very well documented. The exercises and problems stimulate thoughts and help in developing a better understanding of the subject. All the key aspects of the subject are sufficiently addressed, and discussed in the best possible way. It's the code in the book that I love the most, it can be compiled on almost any compiler without almost any change being made to it. I would strongly recommend this book as a textbook to all beginners embarking on a study of data structures and algorithms.

What happened to the sections on string processing, geometric algorithms, and advanced topics? The Introduction says parts 5-8 are contained in a separate volume, but the second volume contains only the part on Graphs (which the intro says is supposed to be Part 7) What gives?

If you need a book to introduce yourself in data structures, thats not your book. This books are for consult, not to learn, cos there are leaks : insuficient code, insuficient large explanations and drawings about TDAs. Furthermore, its expensive.
Even trough that, Id recommended part 5 because its a good collection of the most used algorithms based in graphs.

Any professional programmer would benefit from having these books at hand. Excellent discussions of the basic algorithms which every programmer needs to know.

But I would like to particularly highlight the discussions on binary and n-ary search trees. The most enlightening discussion in print, giving the reader a real synoptic view of search tree algorithms, how they evolved, and their culmination in red-black trees.

Other reviewers have mentioned that the algorithms as presented here seem to be just warmed=over versions of their C counterparts presented in the C edition of this work. There is a germ of truth to this, but I really don't consider it to be a valid criticism of the books. The point here is not to present C++ coding techniques, but to understand algorithms. If you want to know what a state-of-the art C++ implementation of Red-Black trees looks like, just read the source code which comes with the GNU compiler toolchain. But you're not going to have a prayer of understanding it until you first understand how Red-black trees work--that's where this book comes in. If you are trying to explain the Red-black tree algorithm, you don't want all of the C++ do-dads and optimizations, templates, etc, all cluttering up the presentation of the skeletal algorithm.

...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.

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.

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.

I bought these two book for one reason: to get help implementing algorithms. Since there is lot of code in these books, I thought this would be a good pick. I was wrong. The author is consistently leaving out details vital to understanding the code. He also makes a big deal about abstract data types. This is gloriously of the case. If the readers are supposed to understand the code, transperency would be a more intelligent goal for the author. There are no comments in the code what so ever (yes, this is actually true, not even in the on-line code). The on-line code to this book is a total mess. You would be able to implement all the algorithms from scratch in less time than it would take you to try an piece together the code the author has left for you. The pity is that there are very few other algorithm books that have real code.
Instead of moving on to writing C++ and Java editions of this book, the author should fix the problems with this book and the part 5 book.
Demand a new edition from the author and don't by this one unless you can avoid it. You deserve better.

this is the first algorithms book i read, this is last robert sedgewick book i read.