| | |  | Computer Security | Home » » Algorithms in a Nutshell (In a Nutshell (O'Reilly)) | | | | | | | Description: | | Creating robust software requires the use of efficient algorithms, but programmers seldom think about them until a problem occurs. Algorithms in a Nutshell describes a large number of existing algorithms for solving a variety of problems, and helps you select and implement the right algorithm for your needs -- with just enough math to let you understand and analyze algorithm performance.
With its focus on application, rather than theory, this book provides efficient code solutions in several programming languages that you can easily adapt to a specific project. Each major algorithm is presented in the style of a design pattern that includes information to help you understand why and when the algorithm is appropriate.
With this book, you will: - Solve a particular coding problem or improve on the performance of an existing solution
- Quickly locate algorithms that relate to the problems you want to solve, and determine why a particular algorithm is the right one to use
- Get algorithmic solutions in C, C++, Java, and Ruby with implementation tips
- Learn the expected performance of an algorithm, and the conditions it needs to perform at its best
- Discover the impact that similar design decisions have on different algorithms
- Learn advanced data structures to improve the efficiency of algorithms
With Algorithms in a Nutshell, you'll learn how to improve the performance of key algorithms essential for the success of your software applications.
| | | Product Details: | | | Author:
| George T. Heineman | | Paperback:
| 368 pages | | Publisher:
| O'Reilly Media | | Publication Date:
| October 21, 2008 | | Language:
| English | | ISBN:
| 059651624X | | Product Length:
| 8.9 inches | | Product Width:
| 5.9 inches | | Product Height:
| 0.9 inches | | Product Weight:
| 1.1 pounds | | Package Length:
| 8.9 inches | | Package Width:
| 6.0 inches | | Package Height:
| 0.8 inches | | Package Weight:
| 1.15 pounds | | Average Customer Rating:
|  based on 17 reviews |
| | | | Customer Reviews: | |
Average Customer Review:
 ( 17 customer reviews )
Write an online review and share your thoughts with other customers.
Most Helpful Customer Reviews
91 of 98 found the following review helpful:
 A great supplemental book on AlgorithmsOct 25, 2008
By calvinnme
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
66 of 70 found the following review helpful:
Its pedestrian title gives a very wrong first-impression!Dec 13, 2008
By K. Jazayeri
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.
24 of 24 found the following review helpful:
Delivers as advertisedMar 23, 2009
By J. Pease
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.
10 of 11 found the following review helpful:
 Not funny.Nov 06, 2010
By T. B. Gausen
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.
6 of 7 found the following review helpful:
Quickly locate algorithms that relate to the problems that you want to solveOct 05, 2009
By bernie
"xyzzy"
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)
See all 17 customer reviews on Amazon.com
| | |
|
