The Algorithm Design Manual

Admittedly, I haven't read the apparent king "Introduction to Algorithms".

But Skienna's approach is very digestible. I really enjoyed the writing and the concentration on explaining the concepts instead of vomiting up a wall of greek symbols. I would have loved to actually have taken a class from this guy.

This is a wonderful book for software folks, but the store managed to butcher the Kindle edition again. Things like code examples have serious typos that ruin the utility of them. What good is an algorithm book that has typos in the algorithms? I would have given 5 stars for the book itself if it weren't for the typos.

[update - Feb, 2014]

Several other reviewers say that the problems I reported originally with the Kindle edition of this book have been fixed. I no longer own the book (got a refund in 2012), so can't confirm that directly. Changing the review title and upgrading to 5 stars accordingly (I would prefer just to delete the review entirely but that does not appear to be possible).

--------

[original review - Oct, 2012]

It's a good book but I have discovered that key parts of the Kindle edition are garbled, making the book useless. Buy the physical book, not the Kindle edition, don't make my mistake!

For example, take a look at the "ClosestPair(P)" algorithm described on p7 of the hardcover edition, see the preview http://www.the store.com/Algorithm-Design-Manual-Steven-Skiena/dp/1848000693/ref=tmm_hrd_title_0 . Compare that to the same algorithm shown in the Kindle edition: http://www.the store.com/The-Algorithm-Design-Manual-ebook/dp/B0016H523Q/ref=tmm_kin_title_0 . The indentation is completely messed up and worse yet, there are other mistakes like "if dist(s, t) <= d" becomes "if dist(s, t) = d" (the "<=" changes to just "=") that are completely wrong.

You need to have a foundation of mathematics and code before pursuing reading this book. A lot of the text is sadly based on proofs rather than applicable code examples that break down how the problem would be solved in real life on a machine. The idea is how to break down a problem, and approach it; rather than here is how it would be solved in modern code.

A great book if you have some math background. If this is your first approach to algorithms you should try Cormen or Programming challenges. The book has excelent references to other books and a great algorithm catalog at the end.

This book came with pages missing in the first chapter. Some pages were printed reverse (mirrored). The binding and cover felt cheap, and some pages were folded in on themselves. This is a bootlegged copy of the original and I am surprised this is legal to sell on the store. Returned and received a full refund.

This review does not cover the subject matter of the book. This review is about the shortcomings of the Kindle version. You can change the font size, but you cannot change the font type. I've looked at the text on three different devices (2nd generation Kindle Paperwhite, Kindle app on Retina iPad, and Kindle app on Retina MacBook Pro), and the font looks terrible on all three of them. It's quite distracting, and it makes it harder to read. I think that have crisp, clear fonts are important for eBooks. I was so annoyed that I purchased this title again on iBooks on my iPad, and iBooks allows you to change the font. In addition, the fonts are super crisp in iBooks. It's $20 more expensive in iBooks, but I think it's worth the extra money.

Just started working through this book. So far none of the code examples work.

Bummer!

I'll update this review as i continue to work through it.

On page 80 the book binding is starting to fall apart. BUMMER

Designs and theory are to different animals. Designs WORK literally. Theory does not necessarily WORK. Theory only gets you so far but design is what shapes our world.

If you like theory buy this book. If you are a designer don't waste you money.

The major reason i purchased this book is because the price dropped from ~$100 to ~$45. I am so glad i did not spend ~$100.

I purchased this book as a quick reference to the more comprehensive CLRS text. Overall the book is well written and provides examples of how a particular data structure can be used. Having said that there are way too many errors in the current text, example the big-O complexity for Find-Min (pg 85) for an unsorted list is specified as O(1), which is obviously wrong. Similarly, parent of the ith node in a heap us specified as floor(n/2), should be floor(i/2). There are more glaring mistakes, the book needs a comprehensive reedit.

Springer Special Priced Edition.

This edition is licensed for sale only in India, Pakistan, Bangladesh, Sri Lanka and Nepal. Circulation of this edition outside of these territories is UNAUTHORIZED AND STRICTLY PROHIBITED.

I'm a self-taught professional programmer and I decided I wanted to gain more of an understanding of computer science so algorithms was an obvious place to build up my skills.

First, some notes on who this book is appropriate for: this book has numerous examples in C. I was a little bit anxious about this because I have never used C, but Skiena avoids tricks or distractions. I think it's easy to follow the code for any working programmer as long as you don't lie awake at night in mortal fear of pointers.

This book isn't extremely math-heavy, but you do need to some math to follow it. I initially had to put it down and spend some time with a discrete math book before coming back to it so that I could get the most out of it. You should be familiar with: sets, summations, recurrence relations, Boolean algebra, the basics of proofs, and the basics of graphs (what are edges and vertices, what is a cycle, what is a directed/undirected graph, etc). The graphs are especially important because they undergird probably more than half the material here. Unsurprisingly, the chapter on numeric programming has a bit more math, with items related to linear algebra and a touch of calculus. I am not well-versed in those topics so I wasn't able to get a ton out of the discussion of them.

With the warnings out of the way, what makes this book so good? It is well-illustrated and clearly written. Skiena nicely walks the line between beating you over the head with a point and being inscrutable. The text is not too long. The theoretical explanations and mathematical and pseudocode explanations are interwoven with real, working C code and anecdotes from Skiena's career as a consultant helping to design algorithms. In contrast to some other books, Skiena's approach aims to teach you the whys and wherefores of algorithms, rather than simply presenting them as a fait accompli and inundating you with analysis and details (although he gives you plenty of citations you can follow if you want or need that level of gory detail on a particular topic). If you take the time to read carefully, you will acquire some of the vocabulary and tools to solve algorithmic problems, even if you may not get the level of theoretical detail other texts would give.

While the first half of the book is essentially traditional textbook (including exercises I must confess I didn't do), the second half presents a wide array of classes of algorithmic problems with some tips on where to go and how to solve them, but without the level of rigorous detail of the first half. This view from 10,000 feet is engaging and helpful in giving you a broad picture of the wide world in a way that the first half alone couldn't. It is also rather breezy, so it provides something of a breather after the dense and challenging first half.

If you need help understanding parts of the book, Skiena's own lectures (based on the book) are available on his Web site and on YouTube. I also augmented my studies with Sedgewick's lectures on Coursera and the MIT Open Courseware lectures on YouTube on the topic of algorithms.

Overall, I would recommend this book for anyone who quickly wants to get up to speed in algorithms.

I’m a software developer. I looked at several books on algorithms. This one is excellent. I looked at the print version, 2nd edition (2010).

Here's what I like about the book:
- Starts out by defining what an algorithm is.
- Obviously a GREAT deal of effort taken to write the book.
- Clearly written, well organized.
- Relatively straightforward presentation.
- Examples are coded in C.
- Many examples use meaningfully named variables.

I would not call this a beginner book. You need to already be a pretty good programmer, IMO. On the other hand, the diligent reader (with prior programming experience) can learn what they need to know about algorithms from reading this book. The preface makes clear that the book is designed for a computer science major who has already completed "Computer Science II", for a full length course, so definitely not a beginner book.

The book contains many "war stories", tales from the author's experience. I found some of them rather interesting.

About half the book is a "Catalog of Algorithmic Problems". The author asserts that the best approach is to think about your problem, leaf through the catalog, and find the algorithm that someone else has already figured out. It makes sense, so the book seems a good reference. The author states as much, that the catalog is the key part of the book.

One downside of this book is the overwhelming amount of information. By it's comprehensive nature, it is difficult to digest. If you just want to learn the main algorithms, it can be confusing. But that would be a different book, so no stars off, just warning the reader.

Another downside is the author is not the best at explaining some things. Take quicksort, one of those "main algorithms". I would suggest most readers will not be able to learn quicksort from reading the book. There is even an "animation" (Figure 4.5), but no explanation to help the reader understand, and it is not self-explanatory. In contrast, K+R (The C Programming Language) does a fine job of explaining quicksort, as well as several other "main algorithms". I think Skeina could have done a better job explaining some of the algorithms, but that's a pretty rare talent. The book still seems a pretty incredible resource, but perhaps overkill for many programmers.

Also, I verified that there are unfortunately some problems with the index. And there do seem to be a fair number of errata. But most of the errata do not seem that serious. Finally, the author does lapse into the bad habit of confusingly using i,j,k,x,y,etc. variable names when more meaningful names would have certainly made the code clearer. But to me none of these are major enough to take off a star.

Somewhat disappointed with the book after reading all the great reviews here. It has a good collection of exercises of varying difficulty, but that's about the only part that I liked. While the selection of topics is fine, the explanations are sketchy, and often skipping over logical steps in algorithms/proofs. If you are trying to refresh your knowledge, that's ok (still annoying to my taste), but I can't recommend the book as a place to start learning about it. There are plenty of books/online lecture notes/online courses, that do a much better job and are available for free.

I purchased this book to compliment Introduction to Algorithms which sometimes is difficult for me to grasp because of its academic style. So I just read chapter on something in Skiena and then read the same thing in Cormen with proofs and such. It works very well for me.

The Algorithm Design Manual is great. It's very easy to understand and War Stories are awesome :) But code samples have WAY TO MANY errors. For example Skiena says that given example of heapsort is in-place but it's not. Partitioning function of quicksort is simply wrong. He doesn't move position of right side of the array. Implementation with while loops would be easier to understand.

Plus variable names in code snippets could be better. Come on, every software development books says to give meaningful names to variables! But when you see four functions full of "i, j, j k, p"-s it makes understanding actual implementation hard because you can't see all functions at once. By the time you flip three pages back you may forget what each variable is for.

So I definitely recommend this book but I don't understand why publisher doesn't fix the errors in at least Kindle version (which I bought).

Crowdsource it, for example. I'm ready to contribute :)

For those computer science students and programmers who are put off by the style of "Introduction to Algorithms" by Cormen et al., this book is a good alternative. Rather than just being a catalog of algorithms with code and little explanation, this book covers a much needed middle ground and contains a good deal about the analysis and design of algorithms in general along with discussions of common algorithms themselves in an accessible style. In fact, the author makes a point of mentioning in his preface that you will not find a single theorem in this book, and that the purpose of his book is to get working programmers up to speed quickly on both the generalities and specifics of algorithm design.
The first part of the book is on techniques, and covers the basics of modeling algorithms along with "Big Oh" notation, data structures and sorting, dynamic programming, graph algorithms, combinational search, and the concept of intractibility. What makes this section of the book particularly interesting are the author's "war stories" that talk about real world applications of the ideas discussed in each chapter.
Part two of the book, "Resources", is an extensive catalog of algorithmic problems organized by type. For each problem mentioned, the book includes a problem description and discussion, possible implementations, and other algorithmic problems that are related to this one. In the implementation section for each algorithm, the author demonstrates the kinds of questions that the reader should ask when designing his or her own implementation. The C, C++, Fortran, and Pascal code for all algorithm implementations mentioned is on the accompanying CD rather than in the book itself, which helps make the book more compact.
This book is a very good introduction to the methods of algorithm analysis and design, and an encyclopedic reference on many different types of algorithms. Highly recommended.

I studied this book as a refresher, and it helped me become more methodical in designing algorithms, helping me with the hardest part of solving a problem through the use of programming: deciding which methods should be used when.

I've read more than a few algorithm textbooks, and In my opinion, this is the best one, hands down. Some books are more famous, many holds more pages, or list more algorithms, but none is designed like this one. It might not work for a complete novices, as the pace is brisk and the topics non-trivial: but if you can dedicate the effort, you will find yourself rewarded.

This book is actually two books bound in one: the first book guides the astute reader through the practice (and, some would say, art) of algorithm design, rather than teaching them algorithms. Instead of showing premade solutions, Skiena works to explain the thought process that would lead one to designing an algorithm to solve a problem.

The second part is the less interesting of the two, listing many famous and less famous algorithms; most of the times, a web search would prove more convenient, but for the times it doesn't, this book is a handy companion.

This book fills a nice niche -- it is practical enough to be useful and accesible to professional programmers (rather than algorithms researchers or academics) but is build on solid theory as well.
Aside from this, the book has several features to recommend it:
(1) There are "war stories" scattered throughout the text. These are special sections that describe the author's experience working with algorithmic problems "in the field". These are particularly interesting because the present false starts and failures along the way to the final solution. This is a nice change from the standard model of simply presenting algorithms and proving them correct.
(2) Unlike others, such as the popular Cormen, Lieserson, Rivest and Stein text -- which is a bit advanced for beginning study -- this really is an introduction to algorithms. It is quite suitable for, say, undergradutes who have taken a couple of basic CS courses.
(3) Chapter 8 is a 250-page "Catalog of Algorithmic Problems". Here, you will find descriptions of hundreds of standard formulations for algorithmic problems along with the basic solution approaches, and -- this is what really sets it apart -- pointers to implementations of these algorithms. This is part of the overall emphasis of the book: that of understanding standard algorithms in order to avoid "reinventing the wheel".
Overall, I recommend this book for people with some programming experience that would like to take their work to the next level. Hardcore computer scientists (especially those with a more theoretical bent) may also benefit from this book, but should consider it a supplement to one of the more advanced texts, such as the above-mentioned CLRS.

This is a great book on the design of algorithms, emphasizing design over analysis. With perhaps 1/4 of mainframe machine cycles spent sorting, this is an important topic. The first part introduces those topics we forgot as computer science majors; "The Big Oh notation"; data structures, and heuristic methods. I got a lot from the section on dynamic programming, as well as the simulated annealing heuristic. He perhaps too quickly dispenses genetic algorithms. The discussion on "the theory of NP-Completeness" left me behind, but I would return to that section as a reference. The second part of the book is an impressive catalog emphasizing non-numeric algorithms. The accompanying CD adds great value to the book, with the complete book, a web site of algorithms, and audio class lecture.

As an algorithms instructor, this is a fantastic source of homework and exam questions. Most of the questions are not too lengthy or difficult, and many of them are suitable for timed exams or even technical interviews. However, some of the questions are challenging enough to be used for problem sets.

Just reading this book I remembered why software is so interesting.

This is the second DS & ALG book after Drozdek that I can honestly say is great. All the finer points of the subject are explained in language you can understand, followed by snippets of relevant C code and big O analysis. This is like heaven for intermediate to senior Software Engineers. Someone who understands the subject extremely well can convey his thoughts without arrogance or sloppy code. Yes!!

I was looking for good book, to prepare for interview. This book woke up my real interest for algorithms, like another reviewer mentioned, it describes more to what problem class, you can apply what algorithm. I'm sure, I'll read it very frequently, code examples are written in C, I read this book together with Robert Sedgewick "Introduction into Algorithms".

I would recommend this book to everyone, who would like to learn more about algorithms.

I like this book.
It covers a field of fundamentals of computer algorithms. The book explains basic programming mathods, such as dynamic programmind, devide and conquer, backtracking etc.
The book also covers some new fields that are not covered in, for example, Cormens Introduction to Algorithms, such as randomization, genetic algorithms etc.
At the end of the book you can find very interesting catalog of algorithmic problems.
I highly reccomend this book. It is modern and very nice written.

Apart from beeing really useful, this book has two more interesting characteristics: 1. it is very readable 2. it is very amusing/interesting at times. The book is very good if you are a beginner in the subject of computer algorithms, but note that it is not a stand-alone book. You also need a good algorithms textbook to cover the subject of algorithms. Skiena reviews some aspects of the algorithmic theory he regards especially useful/important and presents his interesting perspective, but some times he uses algorithms or techniques he has not presented. What makes this book great is the "War stories", where the author describes real problems and the process that led to the algorithm that solved the problems. Something like Bentley's magnificent book "Programming pearls" (get this one too!). And, of course, the categorized catalog of algorithmic problems, which comprises the bigest part of the book, is almost a guarantee that once you come across a real problem you will shortly know where to look for a solution. Moreover, that solution may already be coded, waiting for you in the CD that comes with the book (which also includes a one-semester lectures of the author in shockwave-audio format).

This is the most approachable book on algorithms I have. Reading should not be a chore, and yet with some of the other algorithms texts, it very tiresome just to find what you are looking for... and you can just forget about understanding those on the first read-through!
What I like about this book is that things are explained clearly without "dumbing down". When I have a quick question about a particular data structure or about which of two solutions would be better for a problem, I always reach for this book first. Money well spent.

I found this book extremely practical, especially for professionals that don't have everyday the occasion to be confronted with real algorithmic problems (I assume that most of the industry-related software programmers / designers / analysts are in this category), thus beeing in need to have a reference at hand "just in case" :-).

Together with "Programming challenges" also from Skiena & co. constitutes a powerful known algorithms references, and supplied with some natural problem-solving talent, could be a succesfull preparation for something like ACM contests or topcoders.com

The book is really hard to read and understand. If you unfamiliar with algorithm at least on a basic level - this book for you is just trash. Everything in this book described on a really deep level and it's valuable only if you wanna learn something about one specific algorithm. It should be on a shelve of professional software engineers. I bought it to prepare myself for the interviews and it's useless.

This book has some excellent information about writing and selecting algorithms, step by step, as well as plenty of pointers to outside information. Chapter 8 in particular is an invaluable reference for quickly implementing a solution to any of many varied problems.
However, the textual explanations are sometimes confusing, with significant "jumps" between concepts that could throw off the beginning algorist. Furthermore, the author discounts entire paradigms of computer programming, giving the text a biased and unbalanced feel.

This book is splitted in two parts.
The first part mostly contains general advices about algorithms, performances, and such.
The second part is more like a huge catalogue of "classical" problems and algorithms related to those, with advices about how to work them. It does not contain algorithms or pseudo-code (or very little), but is more about how to address the problem (and also contains pointers to an implementation).

As an unbiased reviewer :^) I feel that this is the most useful algorithms text written for the real-world algorist. The CD-ROM contains a wealth of information (including the entire repository of implementations found on the affiliated website, and hours of audio lectures from the author's own algorithms course). The catalog of algorithms is also invaluable.

The book's strength lies in its rapid presentation and further links. For a question on a deterministic algorithm, I'd check this first to freshen up and then go to Cormen, Liverson and Rivest. The CD ROM included makes me wish I had Mr. Skeina as a professor as he is obviously excellent at his trade.

1 star for kindle's edition:
still numerous errors in algorithms for kindle's edition (for example in Merge function in Merget sort there is still if len(buffer1)>0 || len(buffer2)>0 but must be len(buffer1) && (AND) len(buffer2)>0) because of that it's really hard to read (mb not even worth it; coz you will spend a lot of time googling the right pseudocode)

There are lots of books out there which will tell you how search methods and heuristics work, but don't give you a single clue on how to write the code. This book helps you with a lot of questions that's on your mind. Besides, the catalog of algorithmic problems is surely a good idea.

Very nicely written book... war stories keep reader interested all the time... would serve as a great companion to Corman's book... basically, can understand the algos. first with this book and get into greater details and proofs using Corman's book..

This book isn't always the easiest to understand. Consider the explanation of Djikstra's Algorithm on p. 206 of the 2nd ed:

"Djikstra's algorithm is the method of choice for finding shortest paths in an edge-and/or vertex-weighted graph. Given a particular start vertex s, it finds the shortest path from s to every other vertex in the graph, including your desired destination t.

"Suppose the shortest path from s to t in graph G passes through a particular intermediate vertex x. Clearly, this path must contain the shortest path from s to x as its prefix, because if not, we could shorten our s-to-t path by using the shorter s-to-x prefix. Thus, we must compute the shortest path from s to x before we find the path from s to t.

"Djikstra's algorithm proceeds in a series of rounds, where each round establishes the shortest path from s to some new vertex. Specifically, x is the vertex that minimizes dist(s, vi) + w(vi, x) over all unfinished 1 <= i <= n, where w(i, j) is the length of the edge from i to j, and dist(i, j) is the length of the shortest path between them."

You got me why people praise this book. I suggest you go with the cormen book. I wonder why in 2013 a book which uses typesetting from the 50s is even in publication. For instance any fraction is written x/y.

Save your money and use wikipedia.