Customer Reviews

Algorithms in a Nutshell (In a Nutshell (O'Reilly))

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

 

 

This new book on algorithms from O'Reilly is a breath of fresh air. Most books on the subject fall into two categories: very dense tomes full of math and heavy on sometime unintelligible pseudocode, or books that basically just give you recipes without much understanding. The second category is the "give a man a fish" type, the first type is the "teach a man to fish, but use ALGOL to do it". Even the author, in his preface, recognizes that this is not the one book on algorithms you'd need if you were on a desert island. On a desert island you have plenty of time and you can carefully digest Cormen's Introduction to Algorithms. However, you're not on a desert island, are you? Thus this book is the link between Cormen's careful theoretical approach that takes time, and books that amount to code dumps.

The first six chapters amount to supplements on the basics of Theory of Algorithm courses: mathematics foundations, sorting, searching, and graphing algorithms. The mathematics here is somewhat lacking, but then the author is assuming you have other books on the subject - this is a book for ramping up quickly. The rest of the book is rather specialized, considering specific families of algorithms that are topical in these times such as path finding in AI, computational geometry, and network flow. They fill in the blanks missing in the standard textbooks. Plus there is plenty of code - real code, not pseudocode - that you can put to work quickly. The product description lacks the table of contents, so I list that next:

Part I: I
Chapter 1. Algorithms Matter
Section 1.1. Understand the Problem
Section 1.2. Experiment if Necessary
Section 1.3. Side Story
Section 1.4. The Moral of the Story
Section 1.5. References
Chapter 2. The Mathematics of Algorithms
Section 2.1. Size of a Problem Instance
Section 2.2. Rate of Growth of Functions
Section 2.3. Analysis in the Best, Average, and Worst Cases
Section 2.4. Performance Families
Section 2.5. Mix of Operations
Section 2.6. Benchmark Operations
Section 2.7. One Final Point
Section 2.8. References
Chapter 3. Patterns and Domains
Section 3.1. Patterns: A Communication Language
Section 3.2. Algorithm Pattern Format
Section 3.3. Pseudocode Pattern Format
Section 3.4. Design Format
Section 3.5. Empirical Evaluation Format
Section 3.6. Domains and Algorithms
Section 3.7. Floating-Point Computations
Section 3.8. Manual Memory Allocation
Section 3.9. Choosing a Programming Language
Section 3.10. References
Part II: II
Chapter 4. Sorting Algorithms
Section 4.1. Overview
Section 4.2. Insertion Sort
Section 4.3. Median Sort
Section 4.4. Quicksort
Section 4.5. Selection Sort
Section 4.6. Heap Sort
Section 4.7. Counting Sort
Section 4.8. Bucket Sort
Section 4.9. Criteria for Choosing a Sorting Algorithm
Section 4.10. References
Chapter 5. Searching
Section 5.1. Overview
Section 5.2. Sequential Search
Section 5.3. Binary Search
Section 5.4. Hash-based Search
Section 5.5. Binary Tree Search
Chapter 6. Graph Algorithms
Section 6.1. Overview
Section 6.2. Depth-First Search
Section 6.3. Breadth-First Search
Section 6.4. Single-Source Shortest Path
Section 6.5. All Pairs Shortest Path
Section 6.6. Minimum Spanning Tree Algorithms
Section 6.7. References
Chapter 7. Path Finding in AI
Section 7.1. Overview
Section 7.2. Depth-First Search
Section 7.3. Breadth-First Search
Section 7.4. A*Search
Section 7.5. Comparison
Section 7.6. Minimax
Section 7.7. NegMax
Section 7.8. AlphaBeta
Section 7.9. References
Chapter 8. Network Flow Algorithms
Section 8.1. Overview
Section 8.2. Maximum Flow
Section 8.3. Bipartite Matching
Section 8.4. Reflections on Augmenting Paths
Section 8.5. Minimum Cost Flow
Section 8.6. Transshipment
Section 8.7. Transportation
Section 8.8. Assignment
Section 8.9. Linear Programming
Section 8.10. References
Chapter 9. Computational Geometry
Section 9.1. Overview
Section 9.2. Convex Hull Scan
Section 9.3. LineSweep
Section 9.4. Nearest Neighbor Queries
Section 9.5. Range Queries
Section 9.6. References
Part III: III
Chapter 10. When All Else Fails
Section 10.1. Variations on a Theme
Section 10.2. Approximation Algorithms
Section 10.3. Offline Algorithms
Section 10.4. Parallel Algorithms
Section 10.5. Randomized Algorithms
Section 10.6. Algorithms That Can Be Wrong, but with Diminishing Probability
Section 10.7. References
Chapter 11. Epilogue
Section 11.1. Overview
Section 11.2. Principle: Know Your Data
Section 11.3. Principle: Decompose the Problem into Smaller Problems
Section 11.4. Principle: Choose the Right Data Structure
Section 11.5. Principle: Add Storage to Increase Performance
Section 11.6. Principle: If No Solution Is Evident, Construct a Search
Section 11.7. Principle: If No Solution Is Evident, Reduce Your Problem to Another Problem That Has a Solution
Section 11.8. Principle: Writing Algorithms Is Hard--Testing Algorithms Is Harder
Part IV: IV
Appendix A. Benchmarking
Section A.1. Statistical Foundation
Section A.2. Hardware
Section A.3. Reporting
Section A.4. Precision

In recent years I have found most other non-textbooks on algorithms to be uninteresting mainly for two reasons. First, there are books that are re-released periodically in a new "programming language du jour" without adding real value (some moving from Pascal to C/C++ to Python, Java or C#). The second group are books that are rather unimaginative collections of elementary information, often augmenting their bulk with lengthy pages of source code (touted as "ready-to-use", but never actually usable).

I almost didn't pay any attention to this book because its title struck me as rather mundane and pedestrian .... what an uncommonly false first-impression that turned out to be!

The is a well-written book and a great practical and usable one for working software developers at any skill or experience level. It starts with a condensed set of introductory material. It then covers the gamut of common and some not-so-common algorithms grouped by problems/tasks that do come up in a variety of real-world applications.

I particularly appreciate the concise and thoughtful - and concise - descriptions -- chock-full of notes on applicability and usability -- with absolutely no fluff! If nothing else, this book can be a good quick index or a chit sheet before culling through more standard textbooks (many of which, in fact, mentioned as further references in each section).

I believe the authors have identified a valid "hole" in the technical bookshelves - and plugged it quite well! Regarding the book's title, ... now I feel it's just appropriately simple, honest, and down-to-earth.

The book does not aim to be an introduction to, nor the definitive encyclopedia on, the subject of algorithms.

It is intended, as advertised on the cover, as "A Desktop Quick Reference". In the Preface it states that the goal is to provide a useful tool for working programmers to find good solutions to the problems they solve.

As a self-taught programmer I am finding this book interesting to better understand the various ways that the same problem can be solved, and the pros and cons of each. While the book is mainly intended to help programmers review and select appropriate algorithms for a problem at hand, I am using it as a study guide and have enjoyed it as such thus far. While it doesn't exactly make for light reading, each algorithm is considered individually, which makes for a decent size chunk of information which can be considered independently.

Multiple languages (C, C++, Java, Ruby) are used throughout the book in demonstrating the algorithms, solutions are not provided in each language for each algorithm. However, if you are using this as a study guide, this can provide a good exercise to translate the solution into the language of your liking.

This book didn't appeal much to me. The language is chatty and dry at the same time. It's not entertaining or motivating. I sometimes feel the authors are talking down to their readers. They tell us that a mere 'software practitioner' shouldn't be expected to understand Ford-Fulkerson's method from plain pseudocode, yet THEY (the authors) understood it, as did I. The authors could have explained what exactly is so hard to get about that particular example.

Books of this sort commonly differentiate between data structures and algorithms, and that for a good reason. In this book the two concepts are often mixed together in a mess. E.g. heapsort is introduced on p. 86 as an algorithm, but the binary heap is not clearly explained as a data structure. That is, the book does not mention it's common operations. Later, when we come to Dijkstra's shortest path algorithm on p. 154, the 'decreaseKey' operation is mentioned and used (but not explained!) as if the reader must know what that is. This would be very confusing for readers who have not learned about data structures elsewhere.

On p. 36 we are shown an example of calculating big numbers in scheme. The authors then asks: "Is it an advantage or a disadvantage that the underlying architecture is hidden from us, abstracted away?" (most scheme implementations support 'big ints' transparently).

To investigate this important question two hypotheses (stylishly named Hypotheses H1 and Hypotheses H2) are considered. These are basically stating that computations with big integers are indistinguishable from computations with fixed sized integers. By conducting some clever empirical 'benchmark tests', the authors arrives at the stunning conclusion that computations with big integers gradually become slower as they grow. Hence the hypothesises H1 and H2 are both solidly refuted!

I'm serious, there are graphs and everything, showing how operations get slower as the numbers get bigger. The authors even claim that it's not easy to explain why a discontinuation in the performance plot occurs around 30 bits. (It's easy: small ints are usually stored in their own pointer fields, for quick access. From 32 bits, subtract one for sign and one for indicating that this is not a pointer. Hence 30 bits.) No positive aspects of automatic big integers are mentioned, such as portability or programmers not having to worry about overflow all the time.

Consider the following three hypotheses:

Hypotheses H1.
-> The authors are genuinely and naively serious.

Hypotheses H2.
-> The authors are in jest.

Hypotheses H3.
-> The authors pretends to be serious, in order to approach the level of the readers who might not be informed of the treacherous and surprising performance behavior of arbitrary sized integers.

I cannot prove or refute either of these, but I guess H3 is closer to the truth. If I'm right, this is an example of what I mean when I say the authors are talking down to their readers.

This 'nutshell' has plenty of room for such rubbish, in addition to endless tables of "empirically obtained performance data". These numbers will grow old and irrelevant very quickly.

There was no room, however, for an explanation of the red-black-tree delete operation. Pretty disappointing.

Nor were there room for any code or detailed discussion of linear programming (basically, the authors says 'buy maple and use that'). That's funny: what about other algorithms, like q-sort? Why not use readily available libraries for those too? Well, we should of course, and we do.

But the whole point with a book about algorithms should be to learn about how they work, so that we can modify them to do other things. For instance, understanding q-sort allows you to design similar algorithms, such as one that takes a list of numbers and returns every k-th number of the sorted list, WITHOUT necessarily sorting everything.

Learning how linear programming works would be similarly empowering. And we don't need a book to tell us that we can use maple if we just want to perform regular LP computations.

This is my first Safari book that has the free online edition for 45 days.

I have a pretty good collection of books on algorithms. Many O'Reilly books are among the collection. Yet I am most impressed with" Algorithms in a Nutshell "a desktop quick reference. I won't go into a lot of detail as anybody who purchases this book was already know what they're looking for. I am impressed however that for such a small book this goes into a lot of deep concepts and gives you practical solutions.

The best way to see if this book is useful compared to others is to look at sorting algorithms that you know by heart such as median sort and quick sort. If this book tells you what you already know or even does a better job of explaining what you know this is the book for you. This is definitely the book for me.

Even with these examples, that take very little adjustment to put into the real world, you may want to supplement this book with "Sorting and Searching (The Art of Computer Programming, Volume 3)" by Donald E Knuth, Richard S Varga, and Michael A Harrison.

Even if you are not a programmer this book can help you to understand what programmers and or coders are accomplishing with their programs. For people taking any math discipline school this makes a fantastic supplement to understanding math from a different angle.

Sorting and Searching (The Art of Computer Programming, Volume 3)

i understand that ORA wants to create reader-friendly experiences without too much mathematical syntax and density, but this book is needlessly chatty. for example, the first chapter which discusses the motivation for better algorithms could have been compressed into a single page. the next chapter on bounds and limits (bog-Oh notation etc) was so chatty that i just ended up skipping pages. in comparison, skiena's "algorithm design manual" uses a bit more math, but accomplishes explaining this topic in a much briefer fashion. having read both books, i would recommend skiena's book over this. sorry authors, i really wanted to like this book.

This book is a life saver.
See, I have been in the business for a while, but I have no formal CS education so up to this book I knew I had to say from time to time some buzz words such as 'Big-O of I-don't-know' but I never really understood what those were. I knew from other books what different algorithms do - what's the input, what's the output, but never really could do the mental process of depicting how the algorithm progresses. The authors did a fantastic job in this book. They took an approach that treats algorithms as micro-design-patterns, and the ref-cards used to describe the different algorithms are just pure blow to the head (in a good sense). If you are a hands-on,get-the-job-done-fast-and-correct,elegant-and-clean,deliver-on-time-to-market kind of person - buy this book. Its not shallow or in a nutshell as the title suggests - it's just deep enough to (finally for me) understand.

The book is very well written. This is important for me because I have read some horribly written algorithm books, which is most of the ones I've ever read, actually. Historical stories are provided for certain algorithms when necessary along with some practical applications of algorithms. I particularly enjoyed the fact that the book didn't get too bogged down into theory. The only limitation I would cite is the fact that it doesn't touch on NP completeness.

I wished I had been assigned this book for my algorithms class. If you are looking for a concise detailed explanation of all the major algorithms you are likely to learn in an undergraduate algorithms class then this book is for you.

I'm using this book for my algorithms class and its great. It doesn't have all the algorithms I'm using but whats in here is great. Right now, I would say its a great book to have on hand.

I don't think i can do a better job than the predecessors whom have written great reviews about this book, as a matter of fact i bought this book because of their detailed analysis. What i want to do is to the opportunity to thank the authors of this work and "GREAT" is the only word i'll use. I wish you guys were my professor instead, seriously.