Softpanorama
May the source be with you, but remember the KISS principle ;-)

Contents Bulletin Scripting in shell and Perl Network troubleshooting History Humor

Best Algorithms and Data Structures Books

News

See also

Recommended

Introductory

General

Donald Knuth

Combinatorial, string searching and matching

Sorting and searching

C-based books

C++ based books C C++

Assembler

Perl

Optimization

OS internals
OS_related algorithms Compression Compiler-related
/Program Graphs
Graphs   Random Findings

Humor

Etc

"Great algorithms are the poetry of computer science,
Open Source is just a sometimes well-written prose";

The choice of the first book for a serious student is easy -- it should be TAOCP by Knuth. I also have great respect for R.E. Tarjan, but IMHO nobody can surpass Donald Knuth in this field. Second book should probably be more language oriented (C oriented, if this course uses C).  God forbid to get a toxic cocktail of algorithms and OO programming that is sold in many universities ;-).

While Knuth writing is way too academic and as such difficult to comprehend, he is a honest broker and has the IQ to deliver the "meat" for the topic. More dangerous situation arise when the author is trying to make simple things complex and complex incomprehensible. Example of such an approach can be found in a  book   C++: An Introduction to Data Structures by Larry R. Nyhoff (see my review below). It so overloaded with OO that the key idea of algorithms are lost in OO fog. The main reason here has nothing to do with computer science. It's plain vanilla fashion (plus the desire to "make money fast"). Books by this class of authors are as susceptible for fashion as woman hemline.

This situation actually means that other then TAOCP by Knuth (which is definitely difficult to read) there are very few books on algorithms and data structures for working programmers. A good book is very difficult to find. Most books on the subject were written by the university instructors, so presentation is somewhat superficial, the reality is somewhat distorted and fashion rules...

That means that in many cases content is inadequate for the professional programming. Sometimes they describe algorithms and structures that are mathematically interesting, but impractical. Good authors like Donald Knuth does not trick you like some other authors into believing that you can program algorithm, if you understand how it works. Often there are subtle problems here and there and efficient programming of a particular algorithms  requires deep practical experience (or research) and in good textbooks those areas are highlighted and explained.

Many academic authors are unable correctly program even simple algorithms like Bubblesort, but will overload you with unnecessary formalisms up to the ears. The ability to think algorithmically is an adequate foundation for writing a program, but just a foundation. In reality one need to know "nuts and bolts" of the computer and the programming language used (see assembler and C books pages) as well.  That's where Knuth shines, and what many academic authors lack. One example of a second rate books on the topic are Robert Sedgewick books. 

Algorithms is a difficult field and good comprehension of complex algorithms cannot be achieved without a lot of hard work. Some books gives you a false feeling of mastery of a particular area (for example sorting) by discussion two or three algorithms without mentioning their limitations and tradeoffs involved. For example in sorting large sets the dominant part of the total time might be consumed by not only by comparisons, but by coping of items from virtual memory pages that were replaced. For a very small sets (let's say below 64) factors like overall complexity of the algorithm and the number of operations on each iteration might be more important then the number of comparisons. Also if chances that the set is already nearly sorted are high, that can change the real life behavior of many algorithms

For example often shellsort can be more efficient than Quicksort on some sets and the insertion sort can be faster than shellsort on almost sorted sets of data. With cheap memory Mergesort is usually as good or better as Quicksort, this favorite of academic authors.  Similar complex tradeoffs exists in search. Binary or Fibonacci search can be faster for large sets, but if set is small adaptive search and static perfect hashing functions can be even faster.

It is important to understand that if you search the same item again and again heuristic linear search (that starts with the last found item or move the last found item to the top of the list) can be the fastest. For example, in case of compiler often after scanning a particular identifier by lexical analyzer we need to search it again after one or two tokens like in case of statement i=i+1 (as Donald Knuth had shown the overwhelming majority of assignment statements in real programs has simple forms like a=a op b), so just remembering the last identifier  searched (or some small cache of them) can give us a significant advantage over blind search of the whole table by the most efficient method possible. Those subtle questions of programming of algorithms can only be learned via experiments and experience.

IMHO, generally students should avoid books that emphasize correctness proofs -- such an emphasis usually is a definitive sign of a weak book. Avoid ayatollah of correctness, if you can ;-). It's much much better to read How to Solve It, and than all this verification-related noise.

C is preferable to C++ and Java for the algorithms course. OOP languages including C++ and Java is a mixed blessing as they conceal the "kitchen". Even STL should be used with moderation ;-). Inheritance has almost no relevance to the algorithms field, so IMHO any book about algorithms that discusses inheritance at length is suspect ;-). We should not mix eternal things with just fashionable.

The most dangerous situation arise when the author or teacher does not understand real issues and instead of making complex things simple make simple things complex just for the fun of it because he/she is teaching this junk tenth times and, at last, learned the ropes (it's a kind of a sadistic attitude :-). Overexposure to OOP in algorithms-related course mixes apples with oranges, and I prefer apples and hate oranges. It might be that combination of scripting languages and C or other compiled languages is a better paradigm than overhyped compiler-compiler approach used in OO languages.

As a teacher I believe that the best language for studying algorithms and data structures still is assembler. Contrary to popular wisdom, it is simpler to understand complex data structures using assembler than C or other high level language because data representation in assembler is crystal clear and there is no intermediates between you and machine. I can only site here the opinion of Donald Knuth. In his description of MMIX he wrote (italics are mine):

Many readers are no doubt thinking, "Why does Knuth replace MIX by another machine instead of just sticking to a high-level programming language? Hardly anybody uses assemblers these days.''

Such people are entitled to their opinions, and they need not bother reading the machine-language parts of my books. But the reasons for machine language that I gave in the preface to Volume 1, written in the early 1960s, remain valid today:

Moreover, if I did use a high-level language, what language should it be? In the 1960s I would probably have chosen Algol W; in the 1970s, I would then have had to rewrite my books using Pascal; in the 1980s, I would surely have changed everything to C; in the 1990s, I would have had to switch to C++ and then probably to Java. In the 2000s, yet another language will no doubt be de rigueur. I cannot afford the time to rewrite my books as languages go in and out of fashion; languages aren't the point of my books, the point is rather what you can do in your favorite language. My books focus on timeless truths.

Therefore I will continue to use English as the high-level language in TAOCP, and I will continue to use a low-level language to indicate how machines actually compute. Readers who only want to see algorithms that are already packaged in a plug-in way, using a trendy language, should buy other people's books.

The good news is that programming for RISC machines is pleasant and simple, when the RISC machine has a nice clean design...

I think that the algorithms are the quintessence of open source programming. It's really unfortunate that the concept of open source programming is often used in cult-style fashion and is pushed as panacea as if open source code without decent algorithms means anything...

NOTE: Other sections of this site that might be interesting are C books, OS related algorithms, Compiler books, Open Source Pioneers/Donald Knuth.

Dr. Nikolai Bezroukov


Search Amazon by keywords:

 You can use Honor System to make a contribution, supporting this site


Old News ;-)

Data Abstraction and Problem Solving with C++ Walls and Mirrors (3rd Edition)

by Frank M. Carrano, Janet J. Prichard
The authors try to use C+= as a better C without overburdening students with too much inheritance-related and other non-related OO blah-blah-blah. In the third edition, the authors cover the major part of STL, though.
The book is nicely illustrated. See for example chapter 1 discussion of recursion.
I like that they do not spend too much time and efforts discussing algorithms efficiency
Selection of algorithms is reasonable, although I would like to see the discussion of shell sort in the main text not in exercises: this is a very competitive algorithm for real data. It might be better to discuss more clearly the tradeoffs for sorting algorithms too, beyond simple comparison table on page 475. For example some sorting algorithms are stable (preserve the order of same elements), some not. Some sorted algorithms work well with the list representation some don't, etc. Another important in practice case is the behavior of algorithms on semi-sorted (let's say only k items is out of order, where k <<n) and reversely sorted arrays. It also might deserve some discussion outside usual quicksort worst case discussion.
Although this should not bother students, graph chapter is limited to non oriented graphs.
5 out of 5 stars The best introductory book for Data Structures, November 14, 1999
Reviewer: An Amazon.com Customer
This book does an excellent job of introducing the mechanics of Data structures. A very useful book to refresh one's knowledge about data structures and get a rigorous insight in the subject in preparation for advanced studies in the area of Data Structures.

Good book for an introductory University course in Data Structures. This book has been successfully used (and is still being used) as a standard textbook in an intro course in Data Structures at UT Austin

Prerequisites: At least 1 introductory programming course in any high level language (preferably C++). A decent knowledge of C++. (no need of OOP knowledge). Reader should be prepared to seriously study this book.

This is a full blown ACADEMIC book, not a tutorial

5 out of 5 stars Good book..., January 27, 2003
Reviewer: A reader from Chicago, IL
This book is very well written. The language is very clear, but the topic is rather dense. You need to read, then think, then read again.

Many of the examples in the book are given in Pseudo-code. I like that. It makes it easy to follow the logic of the author and figure out how to code it yourself. It doesn't "give" you the answers.

The Section on recursion is basic, but good (think standard "Hanoi Towers"). The section on Algorithm Efficiency and Sorting is very well done...

Overall, I have not looked at too many of these books, so don't necessarily take my review as authoritative. All I can say is that the language and presentation of the topics in this book is very clear and understandable...

5 out of 5 stars Excellent Primer on Data Structures, November 11, 2000
Reviewer: David Kaye from Ann Arbor, MI
I used this book for CPS 272 at Washtenaw Community College and found it very clear. The explanations are thorough and very understandable, and the example code is the clearest code I have ever seen (is this really C++?!). When I transfered to the University of Michigan, I used "Data Structures, Algorithms, and Applications in C++" by Sartjai Sahni for EECS 380, which I wouldn't recommend to anyone. I found myself constantly referring back to Carrano's text. The only thing I have against it is that it doesn't cover algorithm efficiency and big-O notation well enough, but I have no hesitation giving it 5 stars. 5 out of 5 stars Get you started on good programming style, March 2, 2000
Reviewer: Zhang Xue-jin (see more about me) from Lincoln, NE USA
I would not recommend this book to beginners but this book is definately a good book for people with some programming foundation. Advanced data structures are well explained. We are using this book at school and I am totally comfortable with it. I can actually accomplish something that I've never been able to. On thing that reader need to understand is this book is mostly concentrated on advanced data structure concept. Some reviewers said that it is mostly psudocode and it is true because the author is trying to let you understand the concept of advanced programming. Anyway, this book is a good step stone for you to reach highest programming concepts and skills.

**+ C++: An Introduction to Data Structures by Larry R. Nyhoff

Average Customer Review: ** Hardcover - 700 pages 1 edition (January 21, 1999)
Prentice Hall; ISBN: 0023887257 ; Dimensions (in inches): 1.60 x 9.58 x 7.23
Amazon Price: $73.00

This very expensive book is used in many colleges for Advanced Object Oriented programming course as well as Data Structures course. If you use it in Advanced Object Oriented Programming course you need to cry and run or run and cry ;-). The individual features of C++ discussed in the book are not only complex by themselves, but when put together in a program they interact in highly non-intuitive ways. The author discuss each of the features very briefly and as an isolated entity, giving the readers the illusion of understanding but avoiding discussing any non-trivial issues that arise in practice and typical mistakes. But when they try to program using the book, they're in for a painful surprise. This book is more about STL then data structures and depending on your background your mileage may vary.

In the first three chapters the author delves into C++ arcana and I suspect that a student with just one (and semi-forgotten) course of C++ will be unable to understand this material no matter what. Examples are sketchy and often require some work to make them run. First two or three l labs are especially weak and does not help to refresh C++ for those who did not take C++ cause in the prev semester. The level of understanding of C++ required for those labs is somewhat out of touch with the college reality when students that take this class barely can program in C++ Later labs are OK and labs on strings, vectors and inheritance are actually good. IMHO first two labs are simply unsuitable for most students after a year of C++ experience. And to add insult to injury none of the tricky areas covered in the labs are explained well in the book.

Chapter 1 discusses software development. Extremely weak and superficial treatment of a pretty complex topic. It's clear that the author does not understands the subject in depth and the chapter is completely detached from reality. Any student would be better off reading the "Elements of the Program Style" instead as for programming style and Rapid Development for software development issues. This chapter provides no help of dealing with real problems arising in C++ development. The waterfall model of software development is introduced without even mentioning alternatives, for example "rapid prototyping" approach. The "official" list of software development stages provided in a book is highly misleading. In practice, the phases are intermixed and the process in iterative -- often you need to return from coding to specification after discovering that the approach chosen does not work or that there is a better way to specify the task that leads to a cleaner and/or simpler solution.

Chapter 2 discusses relationship between data structures and abstract data types. Discussion of the primitive C++ data types contains some information that is more appropriate for the assembler class (like the way floating representation stores mantissa ). After that the author discusses arrays. Sparse arrays problem and the storage of multidimensional arrays are completely ignored. Some author claims are suspect. For example of p.52 we read:

"One of the principles of object oriented programming is that an object should be self-contained, which means that it should carry within itself all the information necessary to describe and operate on it. Arrays violate this principle. in particular they carry neither their size nor their capacity within them..."

... " we must pass to Print() not only the array to be displayed but also its size, and this is not consistent with the aims of the object-oriented programming" (italics belongs to the Larry Nyhoff -- NNB).

It's because such nonsense I hate the books that mix OOP with data structures :-). It looks like the author does not understand that C++ implementation of arrays is not universal and in some old procedural languages like PL/1 the size of the array is passed as a hidden parameter and can be retrieved using build-n function ;-). Same is true for scripting languages like Perl. In those languages arrays are pretty much self-contained. Then the author tries to explain structures and fail to provide any reasonable treatment of the real-life aspects of this topic. For example is next to impossible to understand how unions work from the text and I highly recommend to get a different textbook for the topic At the end of the chapter the author extols the virtue of OOP in comparison with the procedure oriented programming although is if we talk about algorithms and data structures, then OO approach is highly suspect and might represents a contemporary religious aberration that will not survive the test of the time.

In Chapter 3 along with explanation of C++ class construct the author managed to discusses strings (without much details. A simple editor listing is provided, a definite plus for the chapter), but then for some reason data encryption algorithms (DES and RSA), and, to ensure that the student completely lost interest, the subject pattern matching is added to the mix :-).

After that the book changes the topic and became more introduction of STL library that a data structure course. As an introduction to STL the book makes sense but as an introduction to data structures probably not. Chapter four discusses stacks. Chapter 5 queues. Chapter 6 is devoted to Templates and Standard containers. Chapter 7 is about ADTs. Chapters 8 and 9 discuss lists. Chapter 10 discusses binary trees. Chapter 11 discusses sorting. Chapter 12 tries to link OOP and abstract data types. Chapter 13 is devoted to trees. Chapter 14 discusses Graphs and Digraphs.

You cannot compare this text to Knuth were you really feel the class of author even if you do not understand half of the material (the respect that might help to return to the subject later in one's professional career.) Here a typical student probably will never understand two-thirds of the material because data structures are obscured by object-oriented arcana. And he/she will not receive anything in return other then strong desire not have anything in common with this subject for the rest of your professional life :-).

**** Algorithms in C, Part 5 Graph Algorithms (3rd Edition) by Robert Sedgewick

Robert Sedgwick is neither Donald Knuth not Robert Tarjan, but his textbook covers digraphs and Knuth's volume for this topic still not written :-). Actually the book covers quite a lot of ground. Quality of C implementations can be better, but that's not essential as you need just a starting point and any reference implementation permits you to dig further.
table of contents

Paperback: 368 pages ; Dimensions (in inches): 0.78 x 9.18 x 7.72

Publisher: Addison-Wesley Pub Co; 3rd edition (August 16, 2001)

ISBN: 0201316633

[Dec 2, 2003] C Programming- The Essentials for Engineers and Scientists by David R. Brooks, D. Gries (Editor), F. B. Schneider

Looks like Intermediate to advanced university textbook that is suitable as an into "Algorithms and Data Structures" textbook. I do not know much about David Brooks but David Gries was a talented author when he was young. Later he went into verification fundamentalism and published nothing on real value. I hope that the book is in the style of Primer on Structured Programming Using Pl/1, Pl/C and Pl/Ct by Richard Conway, D. Gries, which was on of the best intro books on its time. They start the book with explaining of basic I/O. The book also covers some classic algorithms like Searching&Sorting (Ch.8), Basic statistics (Ch.9) and Binary Trees (Ch.10) and probably can be used as a intro "Algorithms and Data Structures" textbook.

Hardcover: 496 pages ; Dimensions (in inches): 1.15 x 9.55 x 7.33

Publisher: Springer Verlag; (June 1999)

ISBN: 0387986324

[Dec 1, 2003] Algorithms on Strings, Trees, and Sequences Computer Science and Computational Biology by Dan Gusfield

Don't be thrown by the "biology" in the title. This book clearly explains the numerous algorithms available for string searching and matching. And it does so without burying you in theory or pages full of math.
Hardcover (June 1997)
Cambridge Univ Pr (Short); ISBN: 0521585198

wiredweird (from USA)

What it says, it says best., August 17, 2003

If you haven't read this book, you don't know biological string matching. The book's focus is clearly on string algorithms, but the author gives good biological significance to the problems that each technique solves. I came away from this book understanding the algorithms, but also knowing why the algorithms were valuable.

No, there isn't any real source code here. That should not be a problem - this book aims above the cut&paste programmer. The book is meant for readers who can not only understand the algorithms, but apply them to unique solutions in unique ways.

String matching is far too broad a topic for any one book to cover. The study can include formal language theory, Gibbs sampling and other non-deterministic optimizations, and probability-based techniques like Markov models. The author chose a well bounded region of that huge territory, and covers the region expertly. The reader will soon realize, though, that algorithms from this book work well as pieces of larger computations. The book's chosen limits certainly do not limit its applicability.

By the way, don't let the biological orientation put you off. DNA analysis is just one place where string-matching problems occur. The author motivates algorithms with problems in biology, but the techniques are applicable by anyone that analyzes strings.

Srinivas Aluru (Iowa State University, USA)
The one book you need to study string algorithms May 22, 2000

This is a great book for anyone who wants to understand string algorithms, pattern matching or get a rigorous algorithmic introduction to computational biology. Comprehensive textbook covering many useful algorithms. Very well written.

devolver@iastate.edu (see more about me) from Iowa
5 out of 5 stars The String Algorithm Bible? May 15, 2000

A wonderful book that covers many of the basic algorithms (Z, Boyer-Moore, Knuth-Morris-Pratt) and then moves on to a wonderful discussion of suffix trees and inexact matching. This is an essential book on the topic, but definitely targeting programmers; if you're not a programmer, this book could be a challenge. Of course, if you're not a programmer, this book may hold little interest to you.

Peter A. Friend (from Los Angeles, California)
One of the best books on string searching and matching June 15, 1998

When you try to teach yourself a subject, you end up buying large numbers of books so that all of the little gaps are filled. Unfortunately, I didn't find this book until AFTER I spent a fortune on others. Don't be thrown by the "biology" in the title. This book clearly explains the numerous algorithms available for string searching and matching. And it does so without burying you in theory or pages full of math. By far, the best book on the subject I have found, especially if you are "into" genetics

[Feb 24, 2001] C++ section of the page was updated.

A Beginner's Guide to Graph Theory by W. D. Wallis,2000

Birkhauser (Architectural); ISBN: 0817641769 ; Dimensions (in inches): 0.69 x 9.51 x 6.41

Practical Introduction to Data Structures and Algorithm Analysis, A (C++ Edition) by Clifford A. Shaffer

Schaffer's book does a creditable job of explaining AVL trees but the implementation of the code isn't the greatest.
Hardcover - 494 pages 1 edition (August 12, 1996)
Prentice Hall; ISBN: 0131907522 ; Dimensions (in inches): 0.98 x 9.55 x 7.27

A reader from San Diego, CA

4 out of 5 stars Above average but recommend others, December 5, 1999

I used this textbook to teach Data Structures and Algorithms at the sophomore-junior level to a class of 100 students. My primary focus is to teach the design and use of DS&A with a secondary focus on implementation in a specific language (Java in this case). From this point of view: Part I is excellent. Part II is above average. The discussion of trees is average with an implicitly narrow view of applications. Part III on sorting and searching is average with the exception of the horrible discussion of benchmarking in 8.8. The data are unqualified and misleading (compiled and interpreted run-times are compared as equals!). The discussion of hashing and B-Trees is poorly organized and narrow. Parts III and IV are oriented towards Java implementation. As such, there is no discussion of the limitations of actually using recursion in an implementation nor the efficient use of object-oriented structures in cache-based architectures. For a better discussion of DS&A, many of my less experienced students found relief in Robert Lafore's book (ISBN 1571690956) and the more advanced students consulted Weiss's text (ISBN 0201357542). For the following term I will try Cormen, Leiserson, and Rivest's classic Introduction to Algorithms (ISBN 0070131430) which uses pseudo-code and Lafore's book as a required supplement.

How Debuggers Work Algorithms, Data Structures, and ArchitectureHow Debuggers Work: Algorithms, Data Structures, and Architecture by Jonathan B. Rosenberg

Paperback - 256 pages 1 edition (September 27, 1996)
John Wiley & Sons; ISBN: 0471149667 ; Dimensions (in inches): 0.65 x 9.28 x 7.54

Compression Algorithms for Real Programmers Peter Wayner

Paperback - 239 pages (August 1999)
Morgan Kaufmann Publishers; ISBN: 0127887741 ; Dimensions (in inches): 0.72 x 9.26 x 7.44

Data Structures and Algorithms in C by Adam Drozdek

Hardcover 2nd edition (June 2000)
Brooks/Cole Pub Co; ISBN: 0534375979

Leda A Platform for Combinatorial and Geometric Computing by Kurt Mehlhorn, Stefan Naher

Hardcover - 1018 pages (February 2000)
Cambridge Univ Pr (Short); ISBN: 0521563291 ; Dimensions (in inches): 2.23 x 10.01 x 7.95

Algorithms and Theory of Computation Handbook by Mikhail J. Atallah

Hardcover - 1296 pages (October 1999)

CRC Press; ISBN: 0849326494 ; Dimensions (in inches): 2.51 x 10.30 x 7.37

1 Algorithm Design and Analysis Techniques
Edward M. Reingold
2 Searching Ricardo Baeza-Yates
Patricio V. Poblete
3 Sorting and Order Statistics
Vladimir Estivill-Castro
4 Basic Data Structures Roberto Tamassia
Bryan Cantrill
5 Topics in Data Structures
Giuseppe F. Italiano Rajeev Raman
6 Basic Graph Algorithms Samir Khuller
Balaji Raghavachari
7 Advanced Combinatorial Algorithms Samir Khuller
Balaji Raghavachari
8 Dynamic Graph Algorithms
David Eppstein Zvi Galil
Giuseppe F. Italiano
9 Graph Drawing Algorithms Peter Eades
Petra Mutzel
10 On-line Algorithms: Competitive Analysis and Beyond
Steven Phillips
Jeffery Westbrook
11 Pattern Matching in Strings
Maxime Crochemore
Christophe Hancart
12 Text Data Compression Algorithms
Maxime Crochemore
Thiery Lecroq
13 General Pattern Matching Alberto Apostolico
14 Average Case Analysis of Algorithms Wojciech Szpankowski
15 Randomized Algorithms
Rajeev Motwani Prabhakar Raghavan
16 Algebraic Algorithms
Angel Diaz
Ioannis Z. Emiris Erich Kaltofen
Victor Y. Pan
17 Applications of FFT
Ioannis Z. Emiris
Victor Y. Pan
18 Multidimensional Data Structures Hanan Samet
19 Computational Geometry I
D. T. Lee
20 Computational Geometry II
D. T. Lee
21 Robot Algorithms
Dan Halperin
Lydia Kavraki
Jean-Claude Latombe 22 Vision and Image Processing Algorithms
Concettina Guerra
23 VLSI Layout Algorithms
Andrea S. LaPaugh
24 Basic Notions in Computational Complexity Tao Jiang
Ming Bala Ravikumar
25 Formal Grammars and Languages Tao Jiang
Ming Bala Ravikumar
Kenneth W. Regan
26 Computability Tao Jiang
Ming Bala Ravikumar
Kenneth W. Regan
27 Complexity Classes Eric Allender
Michael C. Loui Kenneth W. Regan
28 Reducibility and Completeness Eric Allender
Michael C. Loui Kenneth W. Regan
29 Other Complexity Classes and Measures Eric Allender
Michael C. Loui Kenneth W. Regan
30 Computational Learning Theory Sally A. Goldman
31 Linear Programming
Vijay Chandru
M.R. Rao
32 Integer Programming
Vijay Chandru
M.R. Rao
33 Convex Optimization
Stephen A. Vavasis
34 Approximation Algorithms Philip N. Klein
Neal E. Young
35 Scheduling Algorithms
David Karger
Cliff Stein Joel Wein
36 Artificial Intelligence Search Algorithms Richard E. Korf
37 Simulated Annealing Techniques Albert Y. Zomaya
Rick Kazman
38 Cryptographic Foundations
Yvo Desmedt
39 Encryption Schemes
Yvo Desmedt
40 Crypto Topics and Applications I Jennifer Seberry
Chris Charnes Josef Pieprzyk
Rei Safavi-Naini
41 Crypto Topics and Applications II Jennifer Seberry
Chris Charnes Josef Pieprzyk
Rei Safavi-Naini
42 Cryptanalysis Samuel S. Wagstaff, Jr.
43 Pseudorandom Sequences and Stream Ciphers Andrew Klapper
44 Electronic Cash Stefan Brands
45 Parallel Computation Raymond Greenlaw
H. James Hoover
46 Algorithmic Techniques for Networks of Processors
Russ Miller Quentin F. Stout
47 Parallel Algorithms Guy E. Blelloch
Bruce M. Maggs
48 Distributed Computing: A Glimmer of a Theory
Eli Gafni
Index

Data Structures : A Pseudocode Approach With C by Richard F. Gilberg, Behrouz A. Forouzan, 1998)

Hardcover (February 1998)
Pws Pub Co; ISBN: 0534951236

A reader from USA

5 out of 5 stars Very well written Data Structures text! May 28, 1999

This is an incredibly rich Data Structure text presented in a easy to read and straightforward manner. The text layout is appealing to the eye with lots of supporting pictures, diagrams, tables, Pseudocode algorithms, and program code. The Pseudocode is general for any language yet closely relates to C. The program code is in C. The Pseudo code logic covers all data structures very well. ~J Franzmeier

Problems on Algorithms by Ian Parberry

Textbook Binding - 192 pages 1 edition (February 8, 1995)
Prentice Hall; ISBN: 0134335589 ; Dimensions (in inches): 0.37 x 9.22 x 6.97

Introduction to Computing and Algorithms

Textbook Binding - 464 pages (October 1997)
Addison-Wesley Pub Co; ISBN: 0201314517 ; Dimensions (in inches): 0.87 x 9.20 x 7.51

George Perantatos (Atlanta, GA)

An excellent introduction into algorithmic concepts. April 13, 1999

As a teaching assistant for CS1501, Introduction to Computing at Georgia Tech, a successful brain-child of Dr. Shackelford's, I have used this book from both a student's and a teacher's standpoint, and thus feel adept at highlighting its successes.

This book provides a concise, clear review of the basic concepts of algorithmic thought and its subsequent expression and application. After a brief review of the history of computing, the reader is launched into an ever-deepening understanding of basic CS tools from a problem-solving point of view.

Topics of interest include dynamic data structures (BST's, linked lists), array storage, stacks + queues, object-oriented programming, precedence and dependence, and a brief sojourn into higher-level theory concepts.

The highlight, and in my opinion success, of this book is the fact that no "real" programming language is used to notate any examples. Rather, Dr. Shackelford, along with other TA's of recent past, devised a pseudo-language which encapsulates many elements of previous educational languages (such as Pascal); naturally, this language is not vulnerable to obsolescence. Also, since this language can not be practically compiled, the reader is forced to trace through examples on his or her own, building his or her skills in mentally evaluating algorithms.

This book, once limited to the Georgia Tech CS curriculum, has now expanded to many other colleges and universities, and more institutions are becoming interested as the months progress. This text is a must-have for any individual interested in getting a substantial taste in algorithms and computing.

Computer Algorithms Introduction to Design and Analysis by Sara Baase, Allen Van Gelder

Quite expensive book, the value is unclear. None of the authors produced any other algorithm-related book...
Hardcover - 688 pages 3 edition (November 15, 1999)
Addison-Wesley Pub Co; ISBN: 0201612445 ; Dimensions (in inches): 1.26 x 9.51 x 7.80
Other Editions: Hardcover

(Sara Baase also wrote Gift of Fire, A: Social, Legal, and Ethical Issues in Computing)

This is the third edition (the first was in 1988). Here is the table of contents. Some interesting stuff covered:

Great Ideas in Computer Science A Gentle Introduction by Alan W. Biermann, Alan W. Bierman

Paperback - 568 pages 2nd edition (April 1997)
MIT Pr; ISBN: 0262522233 ; Dimensions (in inches): 1.26 x 8.97 x 8.02

The Advent of the Algorithm The Idea that Rules the World

by David Berlinski

Amazon price: $19.60

Hardcover - 368 pages 1st edition (March 6, 2000)
Harcourt Brace; ISBN: 0151003386 ; Dimensions (in inches): 1.18 x 9.30 x 6.25
Amazon.com Sales Rank: 990
Avg. Customer Review: 3.5 out of 5 stars
Number of Reviews: 3

**** The Algorithm Design Manual ~ Book contains CD with full e-text. There is a WEB site Steven S. Skiena, Steve Skiena / Hardcover / Published 1997
Amazon price: $59.95
Web site: The Stony Brook Algorithm Repository This book comes with a substantial electronic supplement, a ISO-9660 compatible, multiplatform CD-ROM, which can be viewed using Netscape, Microsoft Explorer, or any other WWW browser. This CD-ROM contains:

(1) A complete hypertext version of the full printed book. Indeed, the extensive cross-references within the text are best followed using the hypertext version.

(2) The source code and URLs for all cited implementations, mirroring the Algorithm Repository WWW site. Programs in C, C++, Fortran, and Pascal are included, providing an average of four different implementation

(3) Over thirty hours of audio lectures on the design and analysis of algorithms are provided, all keyed to on-line lecture notes. Following these lectures provides another approach to learning algorithm design techniques. Listening to all the audio is analogous to taking a one-semester college course on algorithms!

Algorithms in C++: Fundamentals, Data Structures, Sorting, Searching Robert Sedgewick / Paperback / Published 1999
Amazon price: $39.95
C++: An Introduction to Data Structures. (C and C++ are two distinct programming languages.) ~ Usually ships in 24 hours Larry R. Nyhoff / Hardcover / Published 1999
Amazon price: $65.75
Graph Drawing : Algorithms for the Visualization of Graphs ~ Usually ships in 24 hours Giusepp Di Battista, Peter Eades, Roberto Tamassia, and Ioannis G. Tollis / Hardcover, 432 p. / Published by Prentice-Hall, 1998/ ISBN 0-13301-615-3
Amazon price: $66.00 Positively reviewed at ERCB DDJ Programmer's Bookshelf June 1999???? Mastering Algorithms With Perl Jon Orwant, et al / Paperback / Published 1999
Amazon price: $27.96 ~ You Save: $6.99 (20%)
5. Selection and Adversary Arguments.
Introduction.
Finding Max and Min.
Finding the Second-Largest Key.
The Selection Problem.
A Lower Bound for Finding the Median.
Designing Against an Adversary.

6. Dynamic Sets and Searching.
Introduction.
Array Doubling.
Amortized Time Analysis.
Red-Black Trees.
Hashing.
Dynamic Equivalence Relations and Union-Find Programs.
Priority Queues with a Decrease Key Operation.

7. Graphs and Graph Traversals.
Introduction.
Definitions and Representations.
Traversing Graphs.
Strongly Connected Components of a Directed Graph.
Depth-First Search on Undirected Graphs.
Biconnected Components of an Undirected Graph.

8. Graph Optimization Problems and Greedy Algorithms.
Introduction.
Prim's Minimum Spanning Tree Algorithm.
Single-Source Shortest Paths.
Kruskal's Minimum Spanning Tree Algorithm.
9. Transitive Closure, All-Pairs Shortest Paths.
Introduction
The Transitive Closure of a Binary Relation.
Warshall's Algorithm for Transitive Closure.
All-Pairs Shortest Paths in Graphs.
Computing Transitive Closure by Matrix Operations.
Multiplying Bit Matrices-Kronrod's Algorithm.

10. Dynamic Programming.
Introduction.
Subproblem Graphs and Their Traversal
Multiplying a Sequence of Matrices.
Constructing Optimal Binary Search Trees.
Separating Sequences of Words into Lines.
Developing a Dynamic Programming Algorithm.

11. String Matching.
Introduction.
A Straightforward Solution.
The Knuth-Morris-Pratt Algorithm.
The Boyer-Moore Algorithm.
Approximate String Matching.

12. Polynomials and Matrices.
Introduction.
Evaluating Polynomial Functions.
Vector and Matrix Multiplication.
The Fast Fourier Transform and Convolution.
A reader from Austin, TX USA
2 out of 5 stars OK book. Bad subject matter. February 4, 2000

Using perl to implement data structures and algorithms is kind of a laughable concept. Perl was designed specifically so that users wouldn't have to deal with this sort of thing. Algorithms written in perl are much less portable than algorthms written in a more low level language, and perl's built in data types are so powerful that they make the construction of user defined types unnecessary.

Not to mention the fact that perl does so much behind your back that unless you go rooting through source code it is impossible to get truly accurate time complexity analysis of algorithms implemented in perl.

If you are looking for a good algorithm book, check out Corman's Introduction to Algorithms. If you are looking for a good perl book, check out Programming Perl. If you are looking for a book that will tell you how to do a bunch of weird stuff with perl, check out Conway's Object Oriented Perl. But perl and hardcore algorithm study have never mixed, and god knows they shouldn't.

A reader

4 out of 5 starsmore perl than algorithms ... December 18, 1999

After reading rave reviews about this book all over the net, I decided to check it out. I found it a bit disappointing for several reasons. First, there appear to be type setting errors that are distracting. For example, there are sections with example code with text that follows, only the text that follows appears to be introducing the next code snippet, but is actually describing the snippet above (off by 1 error?) Indeed the final code snippet in a section has no following explanatory text.

This is only a problem early on though because as the book progresses, the authors stop describing the code examples! In fact, I found myself trying to figure out what the text was doing in the chapters since all of the concepts were explained in code (without full explanations in the text). <this is a minor exaggeration>

In addition, I found the unrelated annecdotes and allusions and obscure literary quotes a further distraction. I'm sure there is a certain academic audience that would appreciate this, but I hate having to look up words only to find out I didn't really need to look them up ;-).

Some other things I disliked were the absence of hashes in the data structures section (perl has built in hashes, so you'd think a discussion on what a hash is, and hashing algorithms would be included in a perl algorithms book), and the description of algorithm analysis was too short.

On the up side, the sorting and searching sections are very thorough (the perl code implementing them, not the text explaining the code), as are the other sections. If its perl your after, this book has some of the best perl code in print (save for Joseph Hall's "Effective Perl").

In summary, if you already understand these topics, then this book will show you some excellent perl code to implement them. If you do not understand the data structures and algorithms already, I don't think this book is going to make them crystal clear (though the authors are good about referring the reader to other sources).

4 camels for the high quality perl code and thoroughness, but it could have been 5 if the authors followed through with the type of supporting text that Hall did in EP.


See Also


Introductory

See recommended for better choices

**+ C++: An Introduction to Data Structures by Larry R. Nyhoff

Average Customer Review: ** Hardcover - 700 pages 1 edition (January 21, 1999)
Prentice Hall; ISBN: 0023887257 ; Dimensions (in inches): 1.60 x 9.58 x 7.23
Amazon Price: $73.00

This very expensive book is used in many colleges for Advanced Object Oriented programming course as well as Data Structures course. If you use it in Advanced Object Oriented Programming course you need to cry and run or run and cry ;-). The individual features of C++ discussed in the book are not only complex by themselves, but when put together in a program they interact in highly non-intuitive ways. The author discuss each of the features very briefly and as an isolated entity, giving the readers the illusion of understanding but avoiding discussing any non-trivial issues that arise in practice and typical mistakes. But when they try to program using the book, they're in for a painful surprise. This book is more about STL then data structures and depending on your background your mileage may vary.

In the first three chapters the author delves into C++ arcana and I suspect that a student with just one (and semi-forgotten) course of C++ will be unable to understand this material no matter what. Examples are sketchy and often require some work to make them run. First two or three l labs are especially weak and does not help to refresh C++ for those who did not take C++ cause in the prev semester. The level of understanding of C++ required for those labs is somewhat out of touch with the college reality when students that take this class barely can program in C++ Later labs are OK and labs on strings, vectors and inheritance are actually good. IMHO first two labs are simply unsuitable for most students after a year of C++ experience. And to add insult to injury none of the tricky areas covered in the labs are explained well in the book.

Chapter 1 discusses software development. Extremely weak and superficial treatment of a pretty complex topic. It's clear that the author does not understands the subject in depth and the chapter is completely detached from reality. Any student would be better off reading the "Elements of the Program Style" instead as for programming style and Rapid Development for software development issues. This chapter provides no help of dealing with real problems arising in C++ development. The waterfall model of software development is introduced without even mentioning alternatives, for example "rapid prototyping" approach. The "official" list of software development stages provided in a book is highly misleading. In practice, the phases are intermixed and the process in iterative -- often you need to return from coding to specification after discovering that the approach chosen does not work or that there is a better way to specify the task that leads to a cleaner and/or simpler solution.

Chapter 2 discusses relationship between data structures and abstract data types. Discussion of the primitive C++ data types contains some information that is more appropriate for the assembler class (like the way floating representation stores mantissa ). After that the author discusses arrays. Sparse arrays problem and the storage of multidimensional arrays are completely ignored. Some author claims are suspect. For example of p.52 we read:

"One of the principles of object oriented programming is that an object should be self-contained, which means that it should carry within itself all the information necessary to describe and operate on it. Arrays violate this principle. in particular they carry neither their size nor their capacity within them..."

... " we must pass to Print() not only the array to be displayed but also its size, and this is not consistent with the aims of the object-oriented programming" (italics belongs to the Larry Nyhoff -- NNB).

It's because such nonsense I hate the books that mix OOP with data structures :-). It looks like the author does not understand that C++ implementation of arrays is not universal and in some old procedural languages like PL/1 the size of the array is passed as a hidden parameter and can be retrieved using build-n function ;-). Same is true for scripting languages like Perl. In those languages arrays are pretty much self-contained. Then the author tries to explain structures and fail to provide any reasonable treatment of the real-life aspects of this topic. For example is next to impossible to understand how unions work from the text and I highly recommend to get a different textbook for the topic At the end of the chapter the author extols the virtue of OOP in comparison with the procedure oriented programming although is if we talk about algorithms and data structures, then OO approach is highly suspect and might represents a contemporary religious aberration that will not survive the test of the time.

In Chapter 3 along with explanation of C++ class construct the author managed to discusses strings (without much details. A simple editor listing is provided, a definite plus for the chapter), but then for some reason data encryption algorithms (DES and RSA), and, to ensure that the student completely lost interest, the subject pattern matching is added to the mix :-).

After that the book changes the topic and became more introduction of STL library that a data structure course. As an introduction to STL the book makes sense but as an introduction to data structures probably not. Chapter four discusses stacks. Chapter 5 queues. Chapter 6 is devoted to Templates and Standard containers. Chapter 7 is about ADTs. Chapters 8 and 9 discuss lists. Chapter 10 discusses binary trees. Chapter 11 discusses sorting. Chapter 12 tries to link OOP and abstract data types. Chapter 13 is devoted to trees. Chapter 14 discusses Graphs and Digraphs.

You cannot compare this text to Knuth were you really feel the class of author even if you do not understand half of the material (the respect that might help to return to the subject later in one's professional career.) Here a typical student probably will never understand two-thirds of the material because data structures are obscured by object-oriented arcana. And he/she will not receive anything in return other then strong desire not have anything in common with this subject for the rest of your professional life :-).

3 of 5 stars Less than helpful, May 13, 2000
Reviewer: liz mccraven (see more about me) from New Jersey

I used this book as a student in an online version of a Data Structures class. None of us liked this book. The examples are vague and some of the exercises are misleading. I found the organization of the book to be confusing as well. Not good for learning Data Structures on your own.

3 of 5 stars Not for the faint of heart, January 31, 2000
Reviewer: Jim Hare (see more about me) from St Louis, MO

This book, while perhaps suitable for a more agressive Data Structures course. Was unsuitable for most students in my college Data Structures class after a year of C++ experience. The code presented in the text is very skeletal, with far too many "left as an exercise to the reader" for my taste.

Recommended

***** The Art of Computer Programming : Fundamental Algorithms (Vol 1, 3rd Ed); Donald Ervin Knuth -- this is a really great book. Difficult, but great. The author uses assembler for artificial MIX computer and that provide much deeper understanding of the issues involved that OOP-related blah-blah-blah. Must have, accept no substitutes. See also classic computer books and Softpanorama Hall of Fame/Donald Knuth
There is no and probably in the foreseeable future it would unlikely to appear another book of such depth. The MIX computer will probably be eventually replaced by a RISC machine called MMIX. Meanwhile you can to try out the existing programs for the original MIX using emulators:

**** The Algorithm Design Manual by Steven S. Skiena, Steve Skiena / Hardcover / Published 1997

Book contains CD with full e-text. There is a WEB site
Hardcover - 496 pages Bk&Cd Rom edition (November 1997)

Springer Verlag; ISBN: 0387948600 ; Dimensions (in inches): 1.19 x 9.51 x 7.25
Amazon.com Sales Rank: 19,160

Avg. Customer Review: *****
Number of Reviews: 8
Web site: The Stony Brook Algorithm Repository This book comes with CD-ROM which contains:

(1) A complete hypertext version of the full printed book. Indeed, the extensive cross-references within the text are best followed using the hypertext version.

(2) The source code and URLs for all cited implementations, mirroring the Algorithm Repository WWW site. Programs in C, C++, Fortran, and Pascal are included, providing an average of four different implementation

(3) Over thirty hours of audio lectures on the design and analysis of algorithms are provided, all keyed to on-line lecture notes. Following these lectures provides another approach to learning algorithm design techniques. Listening to all the audio is analogous to taking a one-semester college course on algorithms!

The hitch-hiker's guide to Algorithms. July 28, 1998

A reader from Brussels, Belgium.

The Catalog was my main reason for buying the book. It's an invaluable reference base for people whose boss 'needs an answer by tomorrow'.

+ : The War Stories are fun reading, and do a good job of explaining how theory relates to practice.

- : Restating the obvious at times, while deliberately vague elsewhere.

Net : if you use a greedy heuristic to select your reading, this book probably comes ahead of the pack.

This is a must for programmers June 28, 1999

Antonio Costa (accmdq@mail.esoterica.pt) (see more about me) from Porto, Portugal

This book is very well organized. It really helps identifying and solving problems. Highly recommended.

**** DDJ Essential Books- Algorithms & Data Structure 2

Includes nine books:
  • Data Structures: From Arrays to Priority Queues by Wayne Amsbury
  • Introduction to Algorithms by Thomas H. Cormen, Charles E. Leiserson, and Ronald L. Rivest
  • Information Retrieval: Data Structures & Algorithms edited by William B. Frakes and Ricardo Baeza-Yates
  • Fundamentals of Data Structures by Ellis Horowitz and Sartaj Sahni
  • Reliable Data Structures in C by Thomas Plum
  • Data Structures and Algorithm Analysis in C by Mark Allen Weiss
  • Practical Data Structures in C++ by Bryan Flamig
  • Data Structures, Algorithms and Program Style Using C by James F. Korsh and Leonard J. Garrett
  • Data Structures and Algorithms by Alfred V. Aho, John E. Hopcroft and Jeffrey D. Ullman

Plus more than a dozen articles related to algorithms from Dr. Dobb's Journal!

*** Mastering Algorithms With C by Kyle Loudon, Andy Oram

Paperback - 400 pages (August 5, 1999)
O'Reilly & Associates; ISBN: 1565924533
Table of contents

Sample Chapters
Examples

Errata

Generally it's seems to be better that Robert Lafore book. Contains a chapter on compression and a chapter on encryption. Very sloppy typesetting -- especially of C programs (ugly commentaries that took too much space, etc.). Graph algorithms section is weak. Sorting is not bad, but does not include selection sort (which, in the class of simple sort algorithms, is sometimes better than insertion sort) and Shell sort which simple and under-appreciated algorithm that, for example, on almost sorted data beats much more popular (and somewhat more complex) quicksort. Again the book is not bad, but has a lot of weak points typical for the first edition. Here is one negative comment from Amazon that probably explains weak points better:

1 out of 5 stars Horrid Title UnLike O'Reilly

A reader from Santa Monica, California September 8, 1999

Terse explanations, poor diagrams, poor coding style, poor writing style, and poor information covered on each topic listed in table of contents with probably the exception being the Huffman algorithms for data compression. The book is out of standard with most of O'Reilly's rich text and exhaustive detail and real world working code blocks and monitor like diagrams, but this book is nothing but fill and a terrible disappointment. The book is listed at Amazon as having 400 pages, not true, do not believe it, the book actually has 600. I suggest for the critism that Sedgwick gets, his Algorithms in C++ Parts 1-4 is truly the most detailed book on algorithms and data structures there is and it is the best to be a guru software engineer in problem solving and algorithm and data structure mastery. The next book to read that may be better than Sedgewick's is Sartag Sahni's Algorithms, Data Structures, and Applications in C++ by MacGraw-Hill.

*****Exceptional writing, elegant code, great examples September 13, 1999

A reader from Palo Alto, CA

Mastering Algorithms in C is the most readable algorithms book I've ever encountered. Not only does the author have a tremendous command of English, he has a writing style that is simply a pleasure to read. The author also deserves mention as having one of the cleanest coding styles I've come across. Having taught and worked with computers for over 15 years, I've seen many. It is no easy feat to present the subject of algorithms using real C code in a consistently elegant manner. This book does it wonderfully. Another feature of the book that works exceptionally well is its detailed presentation of interesting (and I emphasize interesting) real-world examples of how various data structures and algorithms in the book are actually applied. I'm a computer science type, so I especially enjoyed the examples about virtual memory managers, lexical analyzers, and packet-switching over the Internet. But the book includes many other examples of more general interest. Students will find all of the examples particularly insightful. Although most of the code in the book does make use of many of the more advanced features of C, an inordinate number of comments have been included which should help even the feeblest of programmer carry on. In addition, there are two great chapters on pointers and recursion. Exceptional writing, elegant code, great examples, not to mention a lot of entertainment value -- O'Reilly has another winner here. I highly recommend it.

*** Sams Teach Yourself Data Structures and Algorithms in 24 Hours  by Robert Lafore, 1999

Table of content Paperback - 523 pages Bk&Cd Rom edition (May 1999)
Sams; ISBN: 0672316331 ; Dimensions (in inches): 1.42 x 9.05 x 7.34
Not bad decent introductory book at a reasonable price. Robert Lafore wrote almost a dozen books about C/C++/Object oriented programming, but from what I can see he is not OO fundamentalist. The last kind of books make him a little bit suspect but he authored Assembly Language Primer for the IBM PC and XT, so let's hope that he is not regular object-oriented junk writer ;-). The book contains demonstration applets -- a novel approach. CD contains DJGPP compiler -- a semidecent 32 bit compiler that was ported from GNU C/C++ Unix compilers -- does not make much sense now when Borland C 2.0 is available from Borland site.

Decent illustrations. I noted flow chart for the Insertion sort which is nice to have. Generally presence of flowcharts can be considered as a sure sign of a realistic non-fundamentalist approach to teaching algorithms and data structures. It's really unfortunate that the book does not have a e-text on the CD. Robert Lafore has also authored:

*** Algorithms in C : Fundamentals, Data Structures, Sorting, Searching by Robert Sedgewick,1997

Overpriced. Very very boring. Bad coding style and a lot of errors.

And for a Professor of Prinston University, the author is not very competent in the topic he writes about. As one reviewer put it " However, I would never recommend this book to anyone interested in learning algorithms for this first time without a fair amount of prior programming experience." . Generally it is very superficial in comparison with TAOCP with (incomplete and badly written) C examples.
The books lacks real contact with reader --it's cold preaching of timeless truth ;-) No e-text is available. I found this book to be too dry to be useful for self-education. Important practical tips that can help to select the best algorithms for a particular situation are completly missing.

Bad illustrations.

Still you can buy it very cheaply and if you do not mind debugging the examples it can be one of reasonable selections as a second book after Knuth. The fact that Sedgewick published versions of the book in several other languages including C++ characterize him as somewhat promiscuous -- real programmers know that the only language (other than assembler) in which you can program algorithms efficiently is C :-). Also his C style is not that great and that worsen the impression about the book. In no way it can be compared with Knuth MIX programs (which are pretty difficult to read :-(, but are very instructive and can serve as an example of attention to tiny details of implementation) when you often see how grandmaster can solve a complex problem with just a few masterstrokes.
Actually one can use more recent (and cheaper) book:
Algorithms in C++: Fundamentals, Data Structures, Sorting, Searching  by Robert Sedgewick , 1999
Forget about C++ in title. It's not about C++ -- it's still mostly algorithms and C.
Answers to exercises (at least half of them), please! July 18, 1999
A reader from RTP, NC

I have decided that authors that are not willing to provide detailed solutions to at least the odd-numbered exercises are not worth reading. Why? Because first, where is the evidence that they know the answers to the exercises they present? But more importantly, how is the reader supposed to actually learn from the exercises if he can't see at least one possible solution and the rationale for that solution? This is the same reason why the Deitel & Deitel books are unacceptable. This isn't college anymore. Let's have some answers...if we knew how to do all this stuff already, we wouldn't need the book!

Why do people like this book? July 7, 1999

Reviewer: A reader from Princeton University

It is strange to me why some people love this book so much. Admittedly, Sedgewick is very respected in his field and knows a lot about sorting algorithms, but his book is still dissapointing and very frustrating to read for a beginning computer science student. He seldom includes complete code in his examples, and where there is code, there are sometimes errors in the code.

This reviewer took Sedgewick's class at Princeton University where this book was the required text, and not only was the text poor, his lectures were terribly boring. He himself even recognized that there were errors in his book, and so he allowed his students and TA's to submit errors found in the book. At the end of the year, the list of references to mistakes in the book took up more than three pages.

This review is not the result of a student upset about his grade (an A is fine with me), but is rather an attempt to warn students about the potential pitfalls that may be encountered in reading Sedgewick's book. I suppose this could be a great book for an intermediate or advanced CS student who doesn't mind the sparse and sometimes erroneous code or the terse language used to describe fairly complex ideas. Also, there are some parts of the book that are well written and a pleasure to read. However, I would never recommend this book to anyone interested in learning algorithms for this first time without a fair amount of prior programming experience.

***+ Data Structures & Algorithms in Java (Mitchell Waite Signature Series)

If you need to use Java for the course this is a decent book

Mitchell Waite, Robert Lafore
Hardcover - 600 pages Bk&Cd Rom edition (April 1998)
Waite Group Pr; ISBN: 1571690956 ; Dimensions (in inches): 1.60 x 9.49 x 8.33

4 out of 5 stars This was an excellent non-academic book on data structures, December 9, 1998
Reviewer: thornkin@hotmail.com from Kirkland, WA

This book is a very accessible text on the subject of data structures and algorithms using Java as the implementation language. I found the book to cover things excellently. The author is very efficient and handles these topics without being either too wordy or not giving enough information. The book approaches the subject from what I would call a non-academic angle. The coverage of Big-O notation is non-mathematicall. The author explains the Big-O speed of each data structure or algorithm but does not go into detail about the mathematical basis of such a number. One falling point for some may be the lack of exercizes. I, for one, did not miss these but if you are looking for a book with them, you'll have to look elsewhere. Overall, I highly recommend this book, especially for someone new to the subject. One last point, while the author fails to give any Java implementation for Red-Black trees, this is the only place in the book where he does so. He clearly explains his reasoning for doing as he does--the subject is quite complicated and the code for it immense. He does, however, give a good theoretical explanation of the subject.

5 out of 5 stars One of the best Data Structures books around, March 31, 2000
Reviewer: wonderrat (see more about me)

I am surprised that most instructors haven't banned this book! It is absolutely one of the best data structures references on the market and with answers provided with the enclosed CD, one perfect "cheat book." Virtually all the standard data structures for an introductory DS&A course are included here with a good explanation behind the rationale used in the implementation of the code. Lafore is a good writer and explains things well, unlike certain authors. The book isn't heavy on the mathematics, which is good for programmers who don't want to get involved with theory. The applets which implement the data structures are particularly nice.

As mentioned in a previous review, trees are not covered well in this book, but most introductory books don't cover them well either. I don't expect to see an analysis of AVL or red-black trees in an introductory book (Cormen's text, which is the standard for grad school, doesn't explain trees well either). In fact, only Schaffer's book does a creditable job of explaining AVL trees but the implementation of the code isn't the greatest. But for linked lists, stacks,queues, and the like, there are few books that are the equal of this one. Buy the book and you'll pass your DS&A class with flying colors!

Data Structures & Algorithm Analysis in Java by Mark Allen Weiss

Hardcover - 560 pages 1 edition (October 1, 1998)
Peachpit Press; ISBN: 0201357542 ; Dimensions (in inches): 0.97 x 9.49 x 7.73
Amazon.com Sales Rank: 18,729
Avg. Customer Review: 4.5 out of 5 stars
Number of Reviews: 5

5 out of 5 stars Definitely one to consider, June 8, 1999
Reviewer: A reader from Seattle, Washington
Definitely one to consider if you're looking for an advanced text on DS&A in Java. Well-written, thorough, and ALL the source code is downloadable on Weiss's site www.cs.fiu.edu/~weiss . This is by far my favorite algorithms text, although I expect Sedgewick's "Algorithms in Java, Parts 1-4" to be comparable when/if it ever is finally published.


General

Note: I would prefer pseudocode based books, but your mileage may vary.

***+ Data Structures : A Pseudocode Approach With C

Richard F. Gilberg, Behrouz A. Forouzan / Hardcover / Published 1998
Usually ships in 24 hours
Average Customer Review: 5 out of 5 stars Hardcover (February 1998)
Pws Pub Co; ISBN: 0534951236

5 out of 5 stars Very well written Data Structures text! May 28, 1999

A reader from USA

This is an incredibly rich Data Structure text presented in a easy to read and straightforward manner. The text layout is appealing to the eye with lots of supporting pictures, diagrams, tables, Pseudocode algorithms, and program code. The Pseudocode is general for any language yet closely relates to C. The program code is in C. The Pseudo code logic covers all data structures very well. ~J Franzmeier

***+ > Foundations of Computer Science Alfred V. Aho, Jeffrey D. Ullman 1995

Old, but not that bad, although far from the level of Knuth.

??? Introduction to Algorithms  by Thomas H. Cormen,1999

Overated book...

Data Structures and Their Algorithms by by Harry R. Lewis, Larry Denenberg

Hardcover - 509 pages (March 1991)
Addison-Wesley Pub Co; ISBN: 067339736X ; Dimensions (in inches): 1.26 x 9.57 x 6.43
Amazon.com Sales Rank: 369,949
Avg. Customer Review: 4.5 out of 5 stars
Number of Reviews: 4
Table of contents
Too short to be useful for such a volume of material.


5 out of 5 stars Great introduction to the subject, wonderful teaching.., March 8, 2000
Reviewer: Carl-Johan Bostorp (see more about me) from Linkцping, Sweden
I seriously like this book. It's explaining is close to crystal clear to me when I read it, and the algorithms listed (in pseudo-code) take it to a practical level.

5 out of 5 stars One of the best books of its type, February 1, 2000
Reviewer: Professor Dana S. Nau from College Park, Maryland
One of the best ways to discover the strengths and weaknesses of a textbook is to teach a course using it. A few years ago I taught a senior-level course on Data Structures using this book. The book was a joy to teach from, and I would happily use it again -- I thought it was one of the nicest textbooks I've ever used.

(In case you haven't figured it out from the above paragraph, I believe that Paul Schreiber's review of this book is far too negative.)


2 out of 5 stars Inadequate Computer Science, October 18, 1997
Reviewer: paulschreiber (see more about me) from Waterloo, Canada
In this book, Lewis and Denenberg attempt to explain data structures and associated algorithms. They rely too heavily on obscure proofs, have few, if any worked-out examples and many ambiguously worded questions. Their assertion that a "high school" math background is needed is clearly false. The book also suffers from poor typesetting.

*** Introduction to Algorithms (MIT Electrical Engineering and Computer Science Series) Thomas H. Cormen, et al / Hardcover / Published 1990
Amazon price: $65.00 Amazon rating: ****+ Boring. Be forewarned this is an intermediate MIT textbook that stress algorithm analysis. Sedgewick's book is more simple, TAOCP is more advanced. The analysis of the algorithms are bit too lengthy. As one Amazon reviewer put it:

Captivating... Masterful... (unless you have a life)

Though quite thorough, this book is a "textbook example" of how boring the subject of computer science can be. Instead of touching on new technologies, such as AI, graphics, or anything else remotely relevant to today's demands on programmers and designers, this book, faithful to its MIT roots, gives a pompous, eggheaded distortion to the field of computers as a whole. Its focus is mainly on such trivialities as algorithm analysis, offering about 10 pages of proofs for each simple assertion. The points that the authors hope to make have no relevance whatsoever in a world in which processor power, not meticulous code optimization, reigns. This book is a waste of matter and not worth the paper it is printed on.

**+ Computer Algorithms, Pseudocode

Ellis Horowitz, et al / Hardcover / Published 1997
Amazon price: $64.95
Amazon rating: The authors wrote several other books. Beware buying this book without browsing it. Here is one of the reviews about C++ based variant of the book:
ravinder@rocketmail.com from U.S.A , July 15, 1998
worst book for c++
The most confusing book I ever read. I am a student at Cal Poly Pomona and I am studying CS. We are using this book for cs240 class. Ever body in the class agrees including the instructor that this book shouldn't be used for teaching. Our instructor is looking for a new book. The ideas and concepts are totally unclear. There are not enough examples. I really feel bad that I wasted my money on this book and now I have to buy another one --This text refers to the hardcover edition of this title

C-based books

See also ../Lang/c.shtml

*** Foundations of Computer Science

by Alfred V. Aho, Jeffrey D. Ullman (Contributor)
Amazon Price: $85.20 Hardcover - 786 pages (January 1995)
W H Freeman & Co.; ISBN: 0716782847 ; Dimensions (in inches): 1.87 x 10.26 x 8.22
Amazon.com Sales Rank: 46,844
Avg. Customer Rating: 4.5 out of 5 stars
Number of Reviews: 7
Table of contents

Preface...ix
Chapter 1 - Computer Science: The Mathematics of Abstraction...1
Chapter 2 - Iteration, Induction, and Recursion................25
Chapter 3 - The Running Time of Programs.......................89
Chapter 4 - Combinatorics and Probability......................156
Chapter 5 - The Tree Data Model................................223
Chapter 6 - The List Data Model................................286
Chapter 7 - The Set Data Model.................................337
Chapter 8 - The Relational Data Model..........................403
Chapter 9 - The Graph Data Model...............................451
Chapter 10 - Patterns, Automata, and Regular Expressions.......529
Chapter 11 - Recursive Description of Patterns.................591
Chapter 12 - Propositional Logic...............................642
Chapter 13 - Using Logic to Design Computer Components.........699
Chapter 14 - Predicate Logic...................................733
Index...776 Overpriced and not that good.

2 out of 5 stars Informative, but terribly unclear, June 29, 2000
Reviewer: Jia Jiang (see more about me) from Provo, UT USA
As a computer science major in Brigham Young University, this book is required for 2 of my Sophomore classes. I am impressed by how much information this book contains. However, it is by no means clearly written. The wording is poor, the examples are vague, and the exercises are especially unmeaningful. Obviously, the author of this book is a computer scientist, but this shouldn't be the excuse for writing such a terrible book. Two third of my class hate this book, and we are thinking about having a festival to burn them together after this semester is over. we are asking for a better book which will hopefully contain the same amount of information, but better wording and examples.

***+ Algorithm Development and Program Design Using C

Gary J. Bronson
Paperback - 780 pages 1 edition (February 15, 1996)
International Thomson Publishers; ISBN: 0314069879
Amazon.com Sales Rank: 490,656
Avg. Customer Review: 3.5 out of 5 stars
Number of Reviews: 3

4 of 5 stars Invaluable for "teach yourself" people., March 16, 1999
Reviewer: rescalan@ucsd.edu from San Diego CA
Solutions in the back of the book for odd numbered end of section exercises make it excellent for those who are learning by themselves. Also book does not cheat users, even those who are just starting. Do not be intimidated by its title, this is a beginner's book. After hitting myself against the likes of Deitel and Deitel "C How to Program", which is positively not a beginner's book, I found this jewel.

5 of 5 stars Excellent Book, June 26, 2000
Reviewer: les anderson (see more about me) from USA
I don't know what the guy above is talking about but the math in this book is very elementary. This book is very clear and has plenty of examples. You benifit from this book having only a rudimentary knowledge of C syntax. I highly recomend this book to anyone who wants to get knowledge of data structures in action.

????? Data Structures : A Pseudocode Approach With C
by Richard F. Gilberg, Behrouz A. Forouzan. Hardcover (February 1998) Amazon price:$61.95

Usually ships in 24 hours
Average Customer Review: 5 out of 5 stars Hardcover (February 1998)
Pws Pub Co; ISBN: 0534951236
Amazon.com Sales Rank: 217,316
Avg. Customer Review: 5 out of 5 stars
Number of Reviews: 1

5 out of 5 stars Very well written Data Structures text! May 28, 1999
Reviewer: A reader from USA

This is an incredibly rich Data Structure text presented in a easy to read and straightforward manner. The text layout is appealing to the eye with lots of supporting pictures, diagrams, tables, Pseudocode algorithms, and program code. The Pseudocode is general for any language yet closely relates to C. The program code is in C. The Pseudo code logic covers all data structures very well. ~J Franzmeier

*** Data Structures Using C

Aaron M. Tenenbaum, et al / Unbound / Published 1990
Amazon Price: $67.00 Avg. Customer Review: ****+ Number of Reviews: 2
Too expensive.

***+ Algorithms in C : Fundamentals, Data Structures, Sorting, Searching

Robert Sedgewick / Paperback / Published 1997
Pretty boring. Bad C code.

*** Data Structures, Algorithms, and Software Principles in C

Thomas A. Standish / Hardcover / Published 1994 Amazon rating: ****+
Number of Reviews: 2
Standish makes extensive use of diagrams to aid in explaining topics that can be confusing at first.

** Data Structures and Algorithm Analysis in C

Mark Allen Weiss / Hardcover / Published 1996.

Amazon rating: Actually the author use C++. Not recommended.

Algorithms and Data Structures : An Approach in C

Charles Bowman / Hardcover / Published 1994

**+ Advanced C Structure Programming : Data Structure Design and Implementation in C

John W. L. Ogilvie / Paperback / Published 1990
Amazon price: $26.95
Bad typographical quality. Strange mixture of software methodology and algorithms

C++ based books
(problematic, unless C++ used as a better C)

C++ is not very suitable language for explaining algorithms -- it's too big and too complex, so one need to struggle with language as much as with algorithm, but still it has STL -- Standard Template Library ... see C++/Algorithms. STL is an interesting subject to study, but probably the best way of using C++ if you need to program algorithms is to use it as a better C. It's wise to try to avoid books that emphasize object oriented approach to this subject too much ;-). You should not mix the eternal things with just fashionable. In any case it makes since to look for the authors who manages to publish at least the second edition of the book. In this field the level of understanding of the subject increases slowly with years of teaching/research and the first edition usually is substantially improved in the subsequent editions.

**** Data Structures and Other Objects Using C++

by Michael Main, Walter Savitch

Amazon Price: $67.00
Paperback - 783 pages, 2 edition (July 25, 2000)
Addison-Wesley Pub Co; ISBN: 0201702975
Other Editions: Paperback

Avg. Customer Rating: 3 out of 5 stars
Number of Reviews: 11

Table of contents

In a a rare book that can be used in both Windows/VC6 and Unix/gcc environments. The authors have a Web page AW Main-Savitch Supplements Data Structures ... Using C++ . The book has a good WEB page with a lot of useful materials. I think it's the best WEB for the book site among books in this section.

These are the supplements for the second edition. The first edition supplements are still available at www.cs.colorado.edu/~main/dsoc1/dsoc.html, though instructors who are using the first edition should be able to shift to the new edition with little change. The primary additions to the second edition are features from the 1998 C++ Standard. Here are links to some summary material:

Sample Course Materials

***+ Data Structures and Problem Solving Using C++

by Mark Allen Weiss

Hardcover - 896 pages 2nd edition (November 5, 1999) Addison-Wesley Pub Co (Net); ISBN: 020161250X
The first four chapters is an intro to some C++ constructs. Chapter 5 is design patterns. Chapter 6 is about algorithm analysis. At this point most students hate the course, instructor, C++ and, especially, the book ;-)

Those few who survived and were able to get to the Chapter 8 and beyond may get something useful from the course. Actually the rest of the book is not that bad. Chapter 15 Graphs and Path contains a decent discussion of the Dijkstra algorithm.

The book covers a lot of interesting things, like Minimum spanning tries (24.2.2)

*** C++: An Introduction to Data Structures

by Larry R. Nyhoff Average Customer Review: ** Hardcover - 700 pages 1 edition (January 21, 1999)
Prentice Hall; ISBN: 0023887257 ; Dimensions (in inches): 1.60 x 9.58 x 7.23
Amazon Price: $73.00

Not recommended, see review

Data Structures and Algorithms in C++

by Adam Drozdek

Amazon Price: $69.95
Availability: Usually ships within 24 hours.
Hardcover - 670 pages 2nd edition (June 30, 2000)
Brooks/Cole Pub Co; ISBN: 0534375979 ; Dimensions (in inches): 1.16 x 9.58 x 7.57

Must read book on Data Structures, June 14, 2000
Reviewer: appan (see more about me) from U.S.
In a world of Data Structures books on C and Pascal, this is the best book on using C++. Particularly, I like Author's style of explaining the concepts by pictures and examples instead of drolling over by numerous definitions.

This book also concentrates on various advanced DS topics including Hash Tables, Advanced Search techniques and Memory Management. Case Studies and Exercises are one of the best I have seen in this field -- in fact, better than Savitch! I wouldn't miss this book. The price is worth the contents. --This text refers to the Paperback edition.

Data Structures in C++: A Laboratory Course

by James Roberge, James Robergй. Textbook Binding (March 19, 1997) Amazon Price:$33.95 Usually ships in 1-2 weeks
Average Customer Review: 5 out of 5 stars. Number of reviews 1
5 of 5 stars Best book to learn data structures, April 11, 2000
Reviewer: rajeev from India
This is the best book i have come across after teaching data structures for more than 6 years. The best part of the book is the prelab exercise and the bridge exercise - not to mention the postlab exercise. This book i recommend to students for not only for their hands on sessions - but use this in their theory sessions as well. Thank you james for bringing in your experiences.

Data Structures With C++

by William Ford

Amazon Price: $73.00
Hardcover - 950 pages 1 edition (June 15, 1995)
Prentice Hall; ISBN: 0024209716 ; Dimensions (in inches): 1.57 x 9.60 x 7.85
Amazon.com Sales Rank: 124,705
Avg. Customer Rating: 4.5 out of 5 stars
Number of Reviews: 5

Publisher page Data Structures with C++

5 out of 5 stars Excellent book with lots of hands-on examples. Recommended., May 24, 1999
Reviewer: A reader from Washington State
Ford and Topp have done an excellent job of creating a text with plenty of hands-on examples. Almost all of the examples compiled correctly with Microsoft Visual C++ with very few changes. A few examples did have minor errors that were easily fixed. If you want a "hands-on" guide to data structures, this book worked for me.

Besides all of the actual C++ examples, the authors include good illustrations and answers to selected exercises. I used this textbook for my Data Structures class and several of the students commented on how they planned to keep the book for future reference.

Algorithms and Data Structures in C++

by Leendert Ammeraal author home page: Ammeraal, L. Amazon Price: $59.99
Paperback - 368 pages 1 edition (May 21, 1996)
John Wiley & Son Ltd; ISBN: 0471963550 ; Dimensions (in inches): 0.95 x 9.24 x 7.33

While C++ has always been sold as the "object-oriented" language, it can be used for a whole range of general computing tasks, like algorithms. This book provides a number of algorithms that are ready-to-run. This will open the door for C++ programmers to linked lists, stacks and queues, trees, arithmetic algorithms, and graph algorithms.

Some Aspects of Programming in C++. Arithmetic. Sorting Arrays and Files. Stacks, Queues and Lists. Searching and String Processing. Binary Trees. B-trees. Tries, Priority Queues and File Compression. Graphs. Some Combinatorial Algorithms. Fundamentals of Interpreters and Compilers. Appendix. Bibliography. Index.

4 out of 5 stars Difficult reading, but Excellent Code, August 2, 1999
Reviewer: turkey5555 (see more about me) from Chapman University, Tucson, AZ
I used this book for my Data Structures course and found it very difficult to decipher. The text is hard to understand and if you haven't had much practice in figuring out C++ code, you definitely will have difficulty with Leendert's examples. However, with a little effort and a lot of work (as well as some help by someone more experienced) the code is decipherable. In fact, if you can figure out these examples, you're well on your way to becoming an expert C++ programmer.

I'd recommend this book for the advanced programmer or the programmer that has a great deal of drive and assistance. All in all, definitely worth taking a close look at.

Data Structures Using C and C++

Y. Langsam, M.J. Augenstein and A.M.Tenenbaum, Prentice-Hall, 1996.
4 out of 5 stars Academic in nature and not for the beginning programmer, September 24, 2000
Reviewer: primus1@home.com (see more about me) from Cardiff, CA United States

First off, my suggestion for this book would be as follows. For the computer science or electrical engineering students taking a data structures class to supplement lecture material. Don't get this book if you come from some other language, know your C at least. If you are a beginning C/C++ programmer that needs to learn data structures without having the benefit of an instructor I wouldn't recommend this book, try something less formal unless you love reading technical books.

The book covers a good amount of material and as the preface of the book states it is meant for a 2 semester course in data structures. The book covers stacks, recursion, queues, list, binary trees, sorting, searching, hashing, graphs, etc... All that is essential to becoming a well founded programmer. There are exercises at the end of each chapter to reinforce the material. The material presented is theoretical in nature not much C/C++ code but that's fine.

My opinion of this book has changed over the last year. I had to purchase the book for my first data structures class in college. After reading just the first chapter I was bewildered and confused! Most of the students agreed with me that it was a confusing book and without the benefit of an excellent instructor we'd surely would've been lost. I cannot stress this enough, unless you are very smart student this book should be a supplement to lecture material. I personally didn't read the chapters until after lecture and it usual for me read material before class.

But now a year after I first opened the book I find it a truly great reference. Certainly the book has grown on me and maybe later I'd probably give it a five. For example, recently I had to write a threaded example for my Windows programming class and I wanted to something time consuming yet simple that actually did something, so I just referred to the book on the fibonacci sequence using recursion and used that.

My final thoughts about this book are a bit strange. First off, this is the only data structures book I have read (so far) therefore my opinion lacks some perspective. At first I didn't like it but as time has passed I find that I really like the book. If you are a student going into a data structures class, most likely you'll be required to get a book on data structures and it's possible that you won't get assigned this book. But I would recommend it after you take the class. If you do get it for your class, don't sell it back to the school! You may just find it useful in the future.

Certainly deserves more than 2 or 3 stars, August 11, 2000
Reviewer: swarnangsu (see more about me) from india
Admitted it is not for a beginner, especially if one doe s not have a proper grasp over C. But did the authors claim that it was for beginners? I found their treatment of data structure to be pretty interesting. The authors mostly give psuedo codes which can be easily converted to an executable program. The numerous challenging problems are a great asset of the book. I haven't given 5 stars to the book primarily due to 2 reasons----- 1. some codes are unnecessarily complicated (BST deletion, AVl tree deletion etc.) 2. though the authors promise data structure in C++, they barely use any object oriented concepts.


4 out of 5 stars Why beginner want to read this book?, April 13, 2000
Reviewer: Peter Liu from Purdue University
I am from Purdue University, this course is a core requirement for Electrical Computer Engineering. I don't understand why are you beginners want to read this book? You have to finished Advanced C Programming before even try to read this book. It is not meant for rookie! This book is Data Structure which teach you algorithms for sorting and search data using binary tree, recursions, linklist and lots other algorithms. There are not much of C code in the book, because once you understand the algorithms, you can implement in any kinds of code you want.

buying info Data Structures in C++ Using the Standard Template Library

by Timothy Budd
Amazon Price: $76.00
Hardcover - 576 pages (October 1997)
Addison-Wesley Pub Co; ISBN: 0201308797 ; Dimensions (in inches): 1.10 x 9.54 x 7.73
Amazon.com Sales Rank: 102,979
Avg. Customer Rating: 2.5 out of 5 stars
Number of Reviews: 11
Used in several university courses. See:

Data Structure Programming : With the Standard Template Library in C++
by Joseph Bergin, et al. Hardcover (June 1998)

Amazon price:$49.95

Perl

Perl probably should not be your first or second language for studying algorithms :-)

Mastering Algorithms With Perl

Jon Orwant, et al / Paperback / Published 1999
Amazon price: $27.96 ~ You Save: $6.99 (20%)
  • Paperback: 701 pages
  • Publisher: O'Reilly; 1 edition (August 1, 1999)
  • ISBN: 1565923987
  • Product Dimensions: 9.2 x 7.1 x 1.3 inches
  • Shipping Weight: 2.2 pounds. (View shipping rates and policies)
  • Average Customer Review: based on 16 reviews. (Write a review)
  • Amazon.com Sales Rank in Books: #52,769
  • Table of Contents
    Index
    Examples
    Errata
    Sample Chapter
    Author Interview MAP makes many promises, but fails to deliver., August 18, 2003
    Reviewer: A reader
    As a guy ( engineer not computer expert ) who uses computers everyday to help his research, I would steer you away from using Perl for any task involving mathematical concepts more complicated than addition/subtraction/multiplication and addition.

    I heard this same advice before buying this book and ignored it, I really wish I had listened back then.

    While MAP has some nice pictures which broadly describe the essential concepts, it will give you no idea as to how to actually implement those ideas. Further, all the code is available in CPAN ( If you don't know CPAN, check it out before going any further - at the very least install a module ) and much ( at least what I attempted to use ) appeared to be broken.

    Authors of computer books are usually good about answering e-mail but these authors did not deign to respond to mine.

    If you are out there, struggling to learn algorithms, I would suggest taking a good computer course on the subject. I'm 99% certain the course will be taught in C/C++ or similar language -these languages have tremendous advantages over Perl when it comes to data structures and, believe me, even as a novice I've come to appreciate them...

    If you really know algorithms and wish to write a few in Perl, you can do without this book. Pick up Deitel & Deitel's 'Perl: How to Program' instead or O'Reilly's basic book ( which is good, but I prefer Deitel and Deitel ) ....besides D&D answer their e-mail.


Combinatorial, String searching and Matching Algorithms

**** Combinatorial Algorithms : Theory and Practice Edward M. Reingold Old classic...
**** Combinatorial Algorithms : Generation, Enumeration, and Search (Discrete Mathematics and Its Applications) ~ Usually ships in 24 hours Donald L. Kreher, Douglas R. Stinson / Hardcover / Published 1998 Amazon price: $74.95
Hardcover - 300 pages (December 1998)
CRC Pr; ISBN: 084933988X ; Dimensions (in inches): 0.93 x 9.51 x 6.40
Amazon.com Sales Rank: 201,171
Avg. Customer Review: 5 out of 5 stars
Number of Reviews: 1

This textbook thoroughly outlines combinatorial algorithms for generation, enumeration, and search. Topics include backtracking and heuristics search methods, applying to various combinatorial structures, such as:

* Combinations
* Permutations
* Graphs
* Designs

Many classical areas are covered as well as new research topics not included in most existing texts, such as:

* Group algorithms
* Graph isomorphism
* Hill-climbing
* Heuristics search algorithms

5 out of 5 stars An engaging and useful text on an important topic., June 12, 1999
Reviewer: Charles Colbourn (Charles.Colbourn@uvm.edu) from Burlington, Vermont, U.S.A.
Combinatorial algorithms are widely used in a diverse set of applications areas from engineering, the biological and physical sciences, mathematics and computation, economics, and so on. In addition to their applied nature, combinatorial algorithms often rely on sophisticated results in combinatorics and algebra and on clever data structures. This makes the task of introducing the multi-faceted world of combinatorial algorithms a difficult one.

Kreher and Stinson have written a modern text that addresses the subject systematically, and from a variety of viewpoints. Their text is engaging and accessible to a senior undergraduate student. Nevertheless, a researcher will also find the text informative and useful. It provides an excellent balance of mathematical background, algorithm development, and algorithm implementation. The book has been designed to support an undergraduate course, and provides further material to support a more intensive graduate level course. The text has well designed chapter notes and exercises; the presentation of the methods through description, pseudocode, and examples is particularly clear. However, it is the selection of topics that makes this text especially good.

Numerous strong texts on graph algorithms are concerned with the analysis of properties of graphs rather than the generation and search for combinatorial objects. Highly structured combinatorial objects, such as error-correcting codes or interconnection networks, are notoriously difficult to find via computational methods. The authors develop a powerful toolkit of algorithms for addressing generation and search problems. They start with simple tools and then use these along with some basic combinatorial mathematics to build quite sophisticated tools. The text provides enough information to develop and understand each of the algorithms presented, and enough pointers for the interested reader to find more.

This is an excellent book. I enjoyed reading it. More importantly, there is no doubt that an interesting course can be taught from this book at either the undergraduate or graduate level. There is enough flexibility in the choice of material and emphasis to support a course on mathematical aspects, algorithmic techniques, or applications.

Combinatorics Topics, Techniques, Algorithms by Peter J. Cameron
Amazon Price: $30.95
Paperback (August 1994)
Cambridge Univ Pr (Pap Txt); ISBN: 0521457610 ; Dimensions (in inches): 0.82 x 9.72 x 6.86
Amazon.com Sales Rank: 241,656
Avg. Customer Review: 5 out of 5 stars
Number of Reviews: 1
Algorithms on Strings, Trees, and Sequences Computer Science and Computational Biology by Dan Gusfield Amazon price: $64.95
Hardcover (June 1997)
Cambridge Univ Pr (Short); ISBN: 0521585198

Don't be thrown by the "biology" in the title. This book clearly explains the numerous algorithms available for string searching and matching. And it does so without burying you in theory or pages full of math.

Avg. Customer Review: 5 out of 5 stars
5 out of 5 stars What it says, it says best., August 17, 2003
Reviewer: wiredweird (see more about me) from USA
If you haven't read this book, you don't know biological string matching. The book's focus is clearly on string algorithms, but the author gives good biological significance to the problems that each technique solves. I came away from this book understanding the algorithms, but also knowing why the algorithms were valuable.

No, there isn't any real source code here. That should not be a problem - this book aims above the cut&paste programmer. The book in meant for readers who can not only understand the algorithms, but apply them to unique solutions in unique ways.

String matching is far too broad a topic for any one book to cover. The study can include formal language theory, Gibbs sampling and other non-deterministic optimizations, and probability-based techniques like Markov models. The author chose a well bounded region of that huge territory, and covers the region expertly. The reader will soon realize, though, that algorithms from this book work well as pieces of larger computations. The book's chosen limits certainly do not limit its applicability.

By the way, don't let the biological orientation put you off. DNA analysis is just one place where string-matching problems occur. The author motivates algorithms with problems in biology, but the techniques are applicable by anyone that analyzes strings.

The one book you need to study string algorithmsThe String Algorithm Bible?One of the best books on string searching and matching
5 out of 5 stars May 22, 2000
Reviewer: Srinivas Aluru from Iowa State University, USA
This is a great book for anyone who wants to understand string algorithms, pattern matching or get a rigorous algorithmic introduction to computational biology. Comprehensive textbook covering many useful algorithms. Very well written.
5 out of 5 stars May 15, 2000
Reviewer: devolver@iastate.edu (see more about me) from Iowa
A wonderful book that covers many of the basic algorithms (Z, Boyer-Moore, Knuth-Morris-Pratt) and then moves on to a wonderful discussion of suffix trees and inexact matching. This is an essential book on the topic, but definitely targeting programmers; if you're not a programmer, this book could be a challenge. Of course, if you're not a programmer, this book may hold little interest to you.
5 out of 5 stars June 15, 1998
Reviewer: Peter A. Friend (see more about me) from Los Angeles, California
When you try to teach yourself a subject, you end up buying large numbers of books so that all of the little gaps are filled. Unfortunately, I didn't find this book until AFTER I spent a fortune on others. Don't be thrown by the "biology" in the title. This book clearly explains the numerous algorithms available for string searching and matching. And it does so without burying you in theory or pages full of math. By far, the best book on the subject I have found, especially if you are "into" genetics
**** Algebraic Combinatorics (Chapman and Hall Mathematics) -- C.D. Godsil; Hardcover The Stanford Graphbase : A Platform for Combinatorial Computing Donald Ervin Knuth / Hardcover / Published 1993 Amazon price: $50.95 Pattern Matching Algorithms ~ Usually ships in 24 hours Alberto Apostolico(Editor), Zvi Galil (Editor) / Hardcover / Published 1997 Amazon price: $69.00
Text Algorithms Maxime Crochemore, Wojciech Rytter / Hardcover / Published 1994
Text processing : algorithms, languages, and applications Allen B. Tucker
Text-Searching Algorithms for Parallel Processors (British Library Research Paper, No 11) C.A. Pogue, O. Willett Information Retrieval : Data Structures & Algorithms William Frakes, et al / Hardcover / Published 1992
Amazon price: $73.00

Graph Algorithms

***** Data Structures and Network Algorithms (CBMS-NSF Regional Conference Series in Applied Mathematics) R.E. Tarjan / Paperback / Published 1983
Amazon price: $29.00 (Special Order) Paperback (December 1983)
Society for Industrial & Applied Mathematics; ISBN: 0898711878
Amazon.com Sales Rank: 92,705
Avg. Customer Review: 4.5 out of 5 stars
Number of Reviews: 2

Contents:

Foundations; Disjoint Sets; Heaps; Search Trees; Linking and Cutting Trees; Minimum Spanning Trees; Shortest Paths; Network Flows; Matchings.

5 out of 5 stars Deservedly a classic, March 23, 2000
Reviewer: Tom Morrisette from New York City, USA
This is a superb book. I taught a graduate level course based on it at Lehigh University in 1984 or 1985. It was awarded the prestigious annual Lanchester prize for book of the year Operations Research Society of America about that time. Robert Tarjan was awarded the ACM's Turing award, computer sciences closest equivalent to the Nobel Prize for his contibutions to the theory of algorithms. This book is an excellent introduction to his work. The algorithms in this book were state of the art when it was published, but I don't know how close they are to today's best.

Most of the optimal algorithms in the book grew out of Tarjan's pioneering work on algorithms that minimizes total complexity by allowing individual chunks of work to consume large amounts of computing resources if they build up "credits" that make subsequent steps more efficient. Until Tarjan used this approach to develop superior algorithms for a number of classical problems, the state of the art had been to limit the resources consumed by each step and bound total complexity by multipying the number of steps by the worst case resource consumption per step.

Tarjan's exposition illustrates the power of abstraction. He uses abstract data types throughout, carefully defining them in terms of their fundamental operations. This approach will be very natural for anyone familiar with object oriented programming.

There is a huge amount of information in very few pages, but it is organized very well. Often Tarjan's carefully chosen words say a lot more than is apparent to casual reader's. I spent one 75 minute period explaining his 12 line proof of one of his algorithms. Then the class demanded that I illustrate how the algorithm actually worked on a real problem, so we spent another 1.5 classes applying the algorithm to a small problem I contrived to exercise all of its boundary conditions.

Other faculty advised me that this book was much too hard for course intended for advanced undergraduate and beginning graduate students, but the students disagreed. More than one commented that the material was hard after first reading, but that after hearing my lectures and rereading their assignments, they realized that it was really pretty easy and that the book presented it well. Most would have appreciated worked out examples to observe the dynamic behavior of the algorithms. One student animated some of the algorithms and went on to write his masters thesis on algorithm animation.

4 out of 5 stars Very clearly written, July 14, 1999
Reviewer: A reader from San Jose, California, USA
A network here mean a graph with with weighted, undirected edges. This short (113 page) book is written in a clear style, and could be used as a textbook, athough it does not include exercises. Emphasis is placed on proving the efficiency of the algorithms presented. No knowlege of graph theory or algorithms is assumed, but knowlege of basic programming and college-entry level math is required.

The first half of the book covers the data structures used in solving the network problems that are presented in the second half. These data structures including disjoint sets, heaps, and search trees. Highlights of this half of the book are Tarjan's proof of the amoritized cost of union find, and explaination of self-adjusting binary trees.

The second half of the book covers four classical network problems: minimum spanning tree, shortest paths, network flows (e.g. min-cut), and matchings.

I found the first half of the book more interesting, because more of it was new to me, and because it seemed more likely to be of practical value to me in my work. I have seen presentations of the network problems before, but not with the analysis of efficiency, and comparison of different approaches.

Robert Tarjan (the author) has written many papers on efficient graph algorithms, and appears to be a pioneer in applying proofs of efficiency to graph algorithm. He is often cited in reference to the efficient graph algorithms he has discovered.

This book was published in 1983, but does not seem to be dated.

**** Introductory Graph Theory [ABRIDGED] Gary Chartrand Amazon price: $9.85

Paperback - 294 pages unabrid edition (April 1985)
Dover Pubns; ISBN: 0486247759 ; Dimensions (in inches): 0.65 x 8.54 x 5.43
Amazon.com Sales Rank: 98,028
Avg. Customer Review: 5 out of 5 stars
Number of Reviews: 3

Graphs and Applications An Introductory Approach (with CD-ROM) by Joan M. Aldous, Robin J. Wilson
Amazon price: $49.95
Paperback - 444 pages 1st edition (January 15, 2000)
Springer Verlag; ISBN: 185233259X ; Dimensions (in inches): 1.12 x 9.27 x 6.75
Amazon.com Sales Rank: 810,663
Table of contents
Graphs & Digraphs G. Chartrand, Linda Lesniak / Hardcover / Published 1996
Amazon price: $79.95 (Special Order)
Table of contents
5 out of 5 stars Thorough, March 24, 2000
Reviewer: Dan Hogan
This was the one book assigned for a class where I did NOT have to go out and buy a few other books in order to round out the assigned text. Chartrand has written books on graph theory directed at students of many different levels, and this one is advanced -- but the keynote attribute of this book its thoroughness and accuracy. The proofs depend upon appropriate use of accurate definitions, and here the definitions are VERY clear and specific -- therefore in constructing the proofs in the exercises the student really comes to understand the meaning of the definitions and the concepts they describe. At first I thought this book was going to be unapproachable because it does not kill you with friendly banter, but I have come to appreciate its solid approach and trustworthiness not to lead anyone astray mathematically. By the way, graph theory is really fun. Don't pass us the chance to study it!
Graph Theory & Its Applications (Discrete Mathematical & Applications Series) Jonathan T. Gross, et al / Hardcover / Published 1998
Amazon price: $69.95 (Special Order)
Graph Drawing : Algorithms for the Visualization of Graphs Giusepp Di Battista, et al / Hardcover / Published 1998
Amazon price: $63.00 Graphs, Networks and Algorithms (Algorithms and Computation in Mathematics, V. 5) Dieter Jungnickel, E. Becker (Editor) / Paperback / Published 1998
Amazon price: $59.95 Bipartite Graphs and Their Applications (Cambridge Tracts in Mathematics, No 131) Hardcover Textbook
Copyright: 1999
Publisher: Cambridge University Press
ISBN: 052159345X
Pages: 271
table of contents Algorithms on Graphs H. T. Lau Format: Hardcover, 231pp.
ISBN: 0830634290
Publisher: McGraw-Hill Professional Publishing
Pub. Date: October 1989
Edition Desc : 1st ed There is also 1991 edition:
Format: Hardcover
ISBN: 0830654291
Publisher: T A B Books
Pub. Date: January 1991 Combinatorial heuristic algorithms with FORTRAN H. T. Lau Paperback - 126 pages January 1986
Springer Verlag; ISBN: 0387171614
Amazon.com Sales Rank: 966,604
Avg. Customer Review: 4 out of 5 stars
Number of Reviews: 1
4 out of 5 stars Combinatorial heuristic algorithms with source code, September 17, 1997
Reviewer: A reader
This book contains combinatorial heuristic algorithms with computer programs in FORTRAN 77. Each of the following regarded problems has been shown to be NP-complete: integer linear programming, zero-one linear programming, zero-one knapsack problem, traveling salesman problem, Steiner tree problem, graph partitioning, k-center location. After a short description of each problem and the presented heuristic algorithm to solve it, the parameter description of the subroutines and the main program is given. The corresponding algorithms are printed directly by the computer. A little example with input and output data illustrates the usage of each computer program
Lecture Notes in Computer Science : Group Theoretic Algorithms and Graph Isomorphism Hoffman Planar Graphs : Theory and Algorithms (North-Holland Mathematics Studies, Vol 140) T. Nishizeki, N. Chiba The linear ordering problem : algorithms and applications G. Reinelt

Sorting and Searching

***** The Art of Computer Programming : Sorting and Searching (Vol 3, 2nd Ed) ~ Usually ships in 24 hours Donald Ervin Knuth / Hardcover / Published 1998
Amazon price: $49.95 Simply the best, but pretty complex. See also classic computer books and Softpanorama Hall of Fame/Donald Knuth *** Algorithms in C : Fundamentals, Data Structures, Sorting, Searching Robert Sedgewick / Paperback / Published 1997
Amazon price: $44.95 **+ Algorithms in C++ : Findamentals, Data Structures, Sorting, Searching Robert Sedgewick / Paperback / Published 1999
Amazon price: $39.95
Algorithms in C++, Parts 1-4 Fundamentals, Data Structure, Sorting, Searching, 3rd Edition - $50.99

Source Code
One can use this book instead of C-based book by the same author. Although the book remains pretty average, this is mostly the book about algorithms not about C++. The author pays some attention to OO, as fashion requires, and then completely forget about it for the rest of the book.
Algorithms on Strings, Trees, and Sequences : Computer Science and Computational Biology ~ Usually ships in 24 hours Dan Gusfield / Hardcover / Published 1997
Amazon price: $59.95
String Searching Algorithms (Lecture Notes Series on Computing, Vol 3) Graham A. Stephen / Hardcover / Published 1994
Introduction to Computational Molecular Biology ~ Usually ships in 2-3 days Joao Carlos Setubal(Contributor), et al / Hardcover / Published 1996
Amazon price: $66.95
Biological and Artificial Intelligence Systems ~ Usually ships in 24 hours Enrico Clementi(Editor), S. Chin (Editor) / Hardcover / Published 1997
Amazon price: $188.00 Computational Approaches in Molecular Radiation Biology : Monte Carlo Methods (Basic Life Sciences, Vol 63) Matesh N. Varma(Editor), Aloke Chatterjee (Editor) / Hardcover / Published 1995
Amazon price: $107.00 (Special Order)
Computational Methods in Molecular Biology (New Comprehensive Biochemistry, Vol 32) Steven L. Salzberg(Editor), et al / Paperback / Published 1999
Introduction to Computational Biology : Maps, Sequences, and Genomes (Interdisciplinary Statistics) Michael S. Waterman / Hardcover / Published 1995
Amazon price: $54.95 (Special Order)
Computational Molecular Biology : Sources and Methods for Sequence Analysis Arthur M. Lesk(Editor)
Classical Algorithms in C++ : With New Approaches to Sorting, Searching, and Selection/Book and Disk Usually ships in 24 hours Nicholas Wilt / Paperback / Published 1995
Amazon price: $31.96 You Save: $7.99 (20%)

Compression

***+ Compression Algorithms for Real Programmers (For Real Programmers) by Peter Wayner Table of contents Amazon price: $35.96 Paperback - 239 pages (August 1999)
Morgan Kaufmann Publishers; ISBN: 0127887741 ; Dimensions (in inches): 0.72 x 9.26 x 7.44
Amazon.com Sales Rank: 33,135
Avg. Customer Review: 4 out of 5 stars
Number of Reviews: 4

** Useful, but filled with many, many errors. May 4, 2000

Reviewer: robert_b (see more about me) from Seattle Washington

Despite the title, "Compression Algorithms for Real Programmers," the true audience for this book is not only programmers, but anyone who would like a brief introduction to compression algorithms and the patent politics impacting their use. The book is rather lightweight on details of the algorithms; as such, it is a good overture for programmers, but a dangerous source from which to create software, as "real" programmers often do.

This book was an introduction to the field for me, and for that I found it valuable. However, even though I am a compression neophyte, I found many errors in the examples and the explanations. What concerns me is that if compression novice, as I am, can find errors, how many more hidden errors are in there that I could not deduce? These mistakes often made it difficult to understand the algorithms the author is trying to explain. Not only must one try to comprehend the algorithms, one must first determine what the author actually meant to write. In addition, there are errors in grammar and typesetting that impact the smooth reading of the sometimes complex text.

The book would have benefited greatly from a careful reading by three editors: a technical reading by someone in the intended audience, a technical reading an expert in the field, and a literary reading to smooth out the writing, correct the grammar and point out the typesetting errors. Had the author and editors been more careful, I would have given the text four stars rather than the two.

Use it as a first book, an introduction, for ideas, and source for references. However, follow up on the references before proceeding to create even a line of code.

good conceptual book
5 out of 5 stars April 26, 2000
Reviewer: Craig Schmidt (see more about me) from Boston, MA
Most of the compression books I've seen have either been very mathematical using a theorem/proof presentation, or code cookbooks that don't explain the ideas very clearly. This book uses that all too rare "conceptual" presentation. It very clearly explains the main ideas in compression, with very few equations. The examples are nicely chosen. I would strongly recommend this as a first book on compression. However, it is also a very enjoyable read for people more familiar with the field. The chapter on patents is very interesting even for experts.
The Data Compression Book by Mark Nelson, Jean-Loup Gailly
Amazon price: $31.96
Paperback - 557 pages 2nd Edition edition (November 1995)
IDG Books Worldwide; ISBN: 1558514341 ; Dimensions (in inches): 1.45 x 9.22 x 7.14
Amazon.com Sales Rank: 54,137
Avg. Customer Review: 3 out of 5 stars
Number of Reviews: 7 a book which has its positive and negative sides...
3 out of 5 stars June 19, 2000
Reviewer: Andrei A. Istratov (see more about me) from Berkeley, CA
PROs: 1. It is one of very few books on data compression available on the market. 2. Description of the IDEAS of compression techniques is very well written. 3. The books comes with the C code for most algorithms. 4. Fairly wide scope of data compression techniques is presented.

CONs: 1. Possibly for copyright reasons, the formats of commonly used file formats are not disclosed; the enclosed propgrams are generic compression algorithms, which do not create (or open) actual .ZIP, .ARC, or .JPG files, which can be opened by commercial programs. Therefore, this book will not help you to open standard compressed files from your home-made programs. 2. There is a missing link between the well described ideas (general principles) of the compression techniques, and their actual algorithms presented as C programs - namely, the algorithms are not described verbally. You have to analyze typically 6-page-long programs to understand how the actual encoding is done. 3. Although there is a section on sound compression, the MP3 standard is not explained. The same applies to MPEG.

SUMMARY: Good to get a general idea how the data compression is performed. Helpful if you want to develop your own compressed data format. Of very limited help if you want to work with standard compressed files in your own program. Requires knowledge of C and some time to study the enclosed code.

Too much about C programming, not enough about compressionThe best book for programmers needing algorithms not theory.Misleading ...
2 out of 5 stars June 15, 2000
Reviewer: Gretta E. Bartels (see more about me) from Seattle, WA
This book's target audience is the novice C programmer who needs to implement data compression of some kind. The authors go to great pains to explain exactly how the code works, but they don't do as good a job on the algorithms themselves. If you are a competent C programmer and/or have any formal training in algorithms, this is probably not the book for you, though it may be a good jumping-off point if it's the only book you can get your hands on.
5 out of 5 stars September 1, 1999
Reviewer: A reader from Florida, USA
This book did a better job than any other of teaching me sliding window dictionary encoding and adaptive huffman encoding. It got right to the point in an easy to understand fashon. There was no thick cloud of theory masking the information I needed. Read this book before you read others on the subject of data compression.
1 out of 5 stars May 24, 1999
Reviewer: A reader
The data compression topics are covered in the most light-handed way possible. The promos for the book advertise that the JPEG compression standard is "discussed", and that source code is provided ... but the source code provided is NOT a JPEG encoder/decoder, but rather an abstract Huffman Table/Quantization program that is ONE HUNDRED FRICKIN' PERCENT USELESS.
Data Compression The Complete Reference by David Salomon
Amazon price: $42.95
Paperback - 448 pages (December 26, 1997)
Springer Verlag; ISBN: 0387982809 ; Dimensions (in inches): 0.85 x 9.24 x 7.08
Amazon.com Sales Rank: 109,254
Avg. Customer Review: 3.5 out of 5 stars
Number of Reviews: 3 Many algorithms included, but no in-depth discussion
3 out of 5 stars May 2, 1999
Reviewer: EECS PhD (eecs_phd@yahoo.com) from Hong Kong
This book explains lots of algorithms, the author tries to give you a brief overview on each of them.

However, if you're interested in the concrete ideas and proofs on how the algorithms help you to compress your data, with some mathematical works, the book isn't enough. You'll find it difficult if you want to implement the algorithms by merely reading the book.

Some idea are not clearly explained too, say, the the information on Gzip is just a summary of the GNU documentation with no in-depth discussion.

Anyway, this book is a great one judging from the (sad) fact that there are not many references on the subject.

Compressed Image File Formats: JPEG, PNG, GIF, XBM, BMP (ACM Press); by John Miano Table of contents Amazon price: $44.95
Textbook Binding - 264 pages Bk&Cd Rom edition (August 19, 1999)
Addison-Wesley Pub Co; ISBN: 0201604434 ; Dimensions (in inches): 0.53 x 9.16 x 7.35
Amazon.com Sales Rank: 16,425
Avg. Customer Review: 4.5 out of 5 stars
Number of Reviews: 3 A detailed reference guide for programmers.
4 out of 5 stars September 27, 1999
Reviewer: A reader from Sunnyvale, CA
I had the opportunity to examine this book both in manuscript and published form, and I must say that I am quite impressed. It provides good overview and detailed implementation notes with source code examples for a variety of image formats. The chapters dedicated to JPEG explore many aspects of the standard and offer suggested implementation notes for both compression and decompression, and the book would be valuable based on this information alone. The remaining chapters discuss the common GIF format and its patent-free successor (PNG) as well as other compressed image formats in regular use. Source code examples in C++ are included in the enclosed CD-ROM along with sample images. In summary, Miano's book provides a sturdy reference for graphics programmers or anyone interested in the details of today's most popular image formats.
Introduction to Data Compression; Khalid Sayood Table of contents Amazon price: $72.95
Hardcover - 475 pages 2 edition (January 1996)
Morgan Kaufmann Publishers; ISBN: 1558603468 ; Dimensions (in inches): 1.12 x 9.65 x 7.71
Other Editions: Hardcover
Overpriced... Managing Gigabytes : Compressing and Indexing Documents and Images (Morgan Kaufmann Series in Multimedia Information and Systems); Ian H. Witten, et al Text Compression (Prentice Hall Advanced Reference Series) by Timothy C. Bell, Ian H. Witten, Ian Whitten (Contributor), John Cleary (Contributor)
Amazon price: $57.00
Availability: Usually ships within 24 hours.
Paperback - 318 pages Facsimile edition (February 1990)
Prentice Hall; ISBN: 0139119914 ; Dimensions (in inches): 0.86 x 9.59 x 7.29
Amazon.com Sales Rank: 134,961
Avg. Customer Review: 4.5 out of 5 stars
Number of Reviews: 4

Optimization

**** Inner Loops : A Sourcebook for Fast 32-Bit Softwc.amazon.com/exec/obidos/ASIN/0070061920/ref=nikolaibezroukov"> The Complete Guide to Mmx Technology ~ Usually ships in 24 hours David Bistry(Editor), et al / Paperback / Published 1997
Amazon price: $59.95 **** Michael Abrash's Graphics Programming Black Book, Special -- Michael Abrash; Paperback Very good book about graphics optimizations. Binary Space Partitioning (BSP) trees are explained. Generally this is a collection of the author's previous books on assembly language and graphics programming, as well as past columns for Dr. Dobb's magazine. The CD-ROM contains the entire text in Adobe Acrobat 3.0 format, allowing fast searches for specific facts. This book is clearly targeted at game developers and serious assembly language programmers, not for the general reader Optimization Algorithms for Networks and Graphs James R. Evans, Edward Minieka / Hardcover / Published 1992
Amazon price: $69.75 (Back Ordered)

Random Findings

Cryptography Theory and Practice (Discrete Mathematics and Its Applications) Douglas R. Stinson Hardcover - 448 pages (March 1995)
CRC Press; ISBN: 0849385210 ; Dimensions (in inches): 1.16 x 9.54 x 6.47
Avg. Customer Review: 5 out of 5 stars
Number of Reviews: 2

5 out of 5 starsBrilliant! September 2, 1999
Reviewer: A customer from Australia

If you could have only one book on cryptography, it should be Schneier's "Applied Cryptography". If you want two, make this your second! While it far outscores the former in terms of depth, it's weaker in breadth, but that's not a problem for any budding cryptologist.

It's a perfect blend of algorithms and mathematics, some of which take a little while to comprehend (if like me, you're not a mathematics graduate), but it's more than worth the effort.

Of all the books in my bookshelves, this would be the one I'd save in a fire. Sorry Knuth. :)

5 out of 5 stars Extraordinary Book on Cryptography September 24, 1998
Reviewer: Paul M. Kwasny (paul@ata.com.pl) from Cieszyn, Poland

Very good book if you are interested in cryptography and secret maths. Not many publication on this topic are written as clear as this. Other like Neal Koblitz's Book on cryptography is a lot harder for people on lower level of maths knowledge. I recommend it to those who want to learn something or for those who want to refresh their memory .

The Advent of the Algorithm The Idea that Rules the World by David Berlinski

Amazon price: $19.60

Hardcover - 368 pages 1st edition (March 6, 2000)
Harcourt Brace; ISBN: 0151003386 ; Dimensions (in inches): 1.18 x 9.30 x 6.25
Amazon.com Sales Rank: 990
Avg. Customer Review: 3.5 out of 5 stars
Number of Reviews: 3

Algorithmics The Spirit of Computing An easy-to-read, for-all-readers algorithms bookJust a great book !Excellent book,although very theoritical
5 out of 5 stars September 3, 1999
Reviewer: ahmaden@starnet.com.eg from Cairo, Egypt
This is a truly magnificent book. It comprehensively covers most of the topics in the analysis and design of alogorithms with no mathematical burden to hamper you from getting through this subjet. Later on, you will most probably need a more intensive and mathmetical-analysis oriented book but be sure this second book will be far more easy to go through after you have have finished the "Algorithmics" book. Enjoy it.
3 of 3 people found the following review helpful:
5 out of 5 stars April 13, 1999
Reviewer: A reader from Finland
This book is just fantastic. It gives a perfect introduction to the most important aspects of algorithm design, correctness, complexity, P vs NP, etc. It has solid foundations in the theory, and brings these difficult concepts within reach of the average programmer, in an easily readable style. Kudos to the author.
5 out of 5 stars December 12, 1998
Reviewer: Mohamed Samy ( samig@gega.net ) from Cairo,Egypt
The book is an introduction to every aspect of algorithm analysis and design ,with chapter on parallel algorithms, algorithm analysis, algorithm design, Turing machines, algorithm correctness and so on. I recommend the book as an introduction since each subject it covers needs a book of it's own so it can't possibly cover every aspect of these topics





Etc

Society

Groupthink : Two Party System as Polyarchy : Corruption of Regulators : Bureaucracies : Understanding Micromanagers and Control Freaks : Toxic Managers :   Harvard Mafia : Diplomatic Communication : Surviving a Bad Performance Review : Insufficient Retirement Funds as Immanent Problem of Neoliberal Regime : PseudoScience : Who Rules America : Neoliberalism  : The Iron Law of Oligarchy : Libertarian Philosophy

Quotes

War and Peace : Skeptical Finance : John Kenneth Galbraith :Talleyrand : Oscar Wilde : Otto Von Bismarck : Keynes : George Carlin : Skeptics : Propaganda  : SE quotes : Language Design and Programming Quotes : Random IT-related quotesSomerset Maugham : Marcus Aurelius : Kurt Vonnegut : Eric Hoffer : Winston Churchill : Napoleon Bonaparte : Ambrose BierceBernard Shaw : Mark Twain Quotes

Bulletin:

Vol 25, No.12 (December, 2013) Rational Fools vs. Efficient Crooks The efficient markets hypothesis : Political Skeptic Bulletin, 2013 : Unemployment Bulletin, 2010 :  Vol 23, No.10 (October, 2011) An observation about corporate security departments : Slightly Skeptical Euromaydan Chronicles, June 2014 : Greenspan legacy bulletin, 2008 : Vol 25, No.10 (October, 2013) Cryptolocker Trojan (Win32/Crilock.A) : Vol 25, No.08 (August, 2013) Cloud providers as intelligence collection hubs : Financial Humor Bulletin, 2010 : Inequality Bulletin, 2009 : Financial Humor Bulletin, 2008 : Copyleft Problems Bulletin, 2004 : Financial Humor Bulletin, 2011 : Energy Bulletin, 2010 : Malware Protection Bulletin, 2010 : Vol 26, No.1 (January, 2013) Object-Oriented Cult : Political Skeptic Bulletin, 2011 : Vol 23, No.11 (November, 2011) Softpanorama classification of sysadmin horror stories : Vol 25, No.05 (May, 2013) Corporate bullshit as a communication method  : Vol 25, No.06 (June, 2013) A Note on the Relationship of Brooks Law and Conway Law

History:

Fifty glorious years (1950-2000): the triumph of the US computer engineering : Donald Knuth : TAoCP and its Influence of Computer Science : Richard Stallman : Linus Torvalds  : Larry Wall  : John K. Ousterhout : CTSS : Multix OS Unix History : Unix shell history : VI editor : History of pipes concept : Solaris : MS DOSProgramming Languages History : PL/1 : Simula 67 : C : History of GCC developmentScripting Languages : Perl history   : OS History : Mail : DNS : SSH : CPU Instruction Sets : SPARC systems 1987-2006 : Norton Commander : Norton Utilities : Norton Ghost : Frontpage history : Malware Defense History : GNU Screen : OSS early history

Classic books:

The Peter Principle : Parkinson Law : 1984 : The Mythical Man-MonthHow to Solve It by George Polya : The Art of Computer Programming : The Elements of Programming Style : The Unix Haterís Handbook : The Jargon file : The True Believer : Programming Pearls : The Good Soldier Svejk : The Power Elite

Most popular humor pages:

Manifest of the Softpanorama IT Slacker Society : Ten Commandments of the IT Slackers Society : Computer Humor Collection : BSD Logo Story : The Cuckoo's Egg : IT Slang : C++ Humor : ARE YOU A BBS ADDICT? : The Perl Purity Test : Object oriented programmers of all nations : Financial Humor : Financial Humor Bulletin, 2008 : Financial Humor Bulletin, 2010 : The Most Comprehensive Collection of Editor-related Humor : Programming Language Humor : Goldman Sachs related humor : Greenspan humor : C Humor : Scripting Humor : Real Programmers Humor : Web Humor : GPL-related Humor : OFM Humor : Politically Incorrect Humor : IDS Humor : "Linux Sucks" Humor : Russian Musical Humor : Best Russian Programmer Humor : Microsoft plans to buy Catholic Church : Richard Stallman Related Humor : Admin Humor : Perl-related Humor : Linus Torvalds Related humor : PseudoScience Related Humor : Networking Humor : Shell Humor : Financial Humor Bulletin, 2011 : Financial Humor Bulletin, 2012 : Financial Humor Bulletin, 2013 : Java Humor : Software Engineering Humor : Sun Solaris Related Humor : Education Humor : IBM Humor : Assembler-related Humor : VIM Humor : Computer Viruses Humor : Bright tomorrow is rescheduled to a day after tomorrow : Classic Computer Humor

The Last but not Least


Copyright © 1996-2014 by Dr. Nikolai Bezroukov. www.softpanorama.org was created as a service to the UN Sustainable Development Networking Programme (SDNP) in the author free time. This document is an industrial compilation designed and created exclusively for educational use and is distributed under the Softpanorama Content License. Site uses AdSense so you need to be aware of Google privacy policy. Original materials copyright belong to respective owners. Quotes are made for educational purposes only in compliance with the fair use doctrine. This is a Spartan WHYFF (We Help You For Free) site written by people for whom English is not a native language. Grammar and spelling errors should be expected. The site contain some broken links as it develops like a living tree...

You can use PayPal to make a contribution, supporting hosting of this site with different providers to distribute and speed up access. Currently there are two functional mirrors: softpanorama.info (the fastest) and softpanorama.net.

Disclaimer:

The statements, views and opinions presented on this web page are those of the author and are not endorsed by, nor do they necessarily reflect, the opinions of the author present and former employers, SDNP or any other organization the author may be associated with. We do not warrant the correctness of the information provided or its fitness for any purpose.

Last modified: January 12, 2014