algorithms

The definitive books on algorithms are widely
acknowledged to be those by Donald Knuth, "The Art of
Computer Programming". Very detailed, and with
voluminous problem sets, they have been the standard
for decades.

Along comes this book with its claim of a different
and complementary classification of the field. The
traditional way is, from a top-down vantage, that at
the highest level, you descend from the root to the
various main problem types. Beneath each problem node
would be subclassifications based on the techniques
used to attack that problem. (I could say "solve", but
that is certainly not the case for some problems.)
This is the most natural classification, because you
often get a problem put in front of you, and you start
from there. Problem-driven.

But what if a method to attack problem A and a method
to attack problem B were very similar? Is there a way
to combine these method nodes? In the problem-driven
tree, not really. So what the author suggests is a
method-driven tree, where problems are descendents of
a method. You regard solutions or research into
problems as instantiations of a particular method.
Sound familiar? You can draw analogies with physics,
if you map the methods into the laws of physics. We
should not follow this too literally. But seen from
this vantage, the author's idea is very reasonable. In
physics, the solutions to a problem are (ideally,
anyway) derived ultimately from the laws of physics.

We should not draw a contrast between the author's
suggestions and the prevailing approach too sharply.
At the research level, a competent analyst should be
aware of different problem areas from which solutions
could be drawn, or to which a solution might be
adapted. As a practical matter, it comes down to the
difference in emphasis for most, rather than a
different worldview.

Nonetheless, this is potentially quite a gem for a
researcher. The author's different emphasis may be the
trigger to solving one of your problems.

As the author says in the preface, there are two ways of presenting algorithms. One classifies algorithms according to a problem type. The other classifies algorithms according to design techniques. A book in the first category will have separate chapters on sorting, searching, graphs etc. These books are like a toolbox. Programmers pick a particular algorithm needed for a problem, modify it if needed and obtain a solution. Most of the algorithm books fall in this category. The problem with this approach is that you have at your disposal only a finite set of algorithms to play with. What if you needed some new kind of algorithm for a specific problem. You are stuck, because most books on algorithms don't teach you how to design new algorithms or what design technique is most suited for your particular problem. It is here that Anany Levitin's book fills the gap. He teaches you the major design techiniques like Brute-Force, Divide-and-Conquer, Greedy techniques. The various algorithms like sorting, searching, graph algorithms are classified according to the various techniques. The advantage of this is that many diverse algorithms get classified according to a particular design technique. For e.g Bubble sort, Convex-Hull problem, Travelling salesman problem, Knapsack problem all fall in the Brute-Force design category. So when you are designing new algorithms you know at the start what type of problem it is and how it should be tackled.
The book teaches you algorithm design and analysis from a completely different view point. It is entertaining to read and the problems at the end of each chapter are wonderful. I only hope that the author adds nore algorithms in his next edition. Go get it!