Softpanorama (slightly skeptical) Open Source Software Educational Society

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

Algorithms and Data Structures

"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 use C). Other then TAOCP by  Knuth there are very few books on algorithms and data structures for working programmers and such a book is 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...  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. There are too many subtle problems here.  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.

Algorithms is a difficult field and comprehension 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 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 sorted are high can change the real life behavior of many algorithms 

For example often shellsort can be more efficient than quicksort on some sets and the insersion sort can be faster than shellsort almost sorted sets of data. With cheap memory mergesort might be as good or better then quicksort. Similar complex tradeoffs exists in search.  Binary of Fibonacci search can be faster for large sets, but if set is small and static perfect hashing functions can be even faster. 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 faster. 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 i=i+1 (as Donald Knuth had shown most assignment statements has simple forms like a=a op b), so just remembering the last identifier (or some small set of them, three or five last searched identifiers) searched can give us 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 then 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 in 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:

• One of the principal goals of my books is to show how high-level constructions are actually implemented in machines, not simply to show how they are applied. I explain coroutine linkage, input-output buffering, random number generation, high-precision arithmetic, radix conversion, packing of data, combinatorial searching, recursion, etc., from the ground up.
• The programs needed in my books are generally so short that their main points can be grasped easily.
• People who are more than casually interested in computers should have at least some idea of what the underlying hardware is like. Otherwise the programs they write will be pretty weird.
• Machine language is necessary in any case, as output of many of the software programs I describe.
• Expressing basic methods like algorithms for sorting and searching in machine language makes it possible to make meaningful studies of the effects of cache and RAM size and other hardware characteristics (memory speed, pipelining, multiple issue, lookaside buffers, the size of cache-lines, etc.) when comparing different schemes.

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 and thus one may benefit for reading sections of this site devoted to the open source programming as well.  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 source code without decent algorithms means anything...

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

Old News ;-)

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

 

by Frank M. Carrano (Author), Janet J. Prichard (Author)

• Hardcover: 944 pages ; Dimensions (in inches): 1.50 x 10.25 x 8.25
• Publisher: Pearson Addison Wesley; 3rd edition (August 9, 2001)
• ISBN: 0201741199 | All Editions
   
• Average Customer Review: Based on 22 reviews. Write a review.
   
• Amazon.com Sales Rank: 258,128

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.

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

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...

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.

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 (Author)
table of contents

Robert Sedgwick is neither Donald Knuth not Robert Tarjan, but his textbook covers digraphs and their textbooks for the 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.

[Dec 2, 2003] C Programming- The Essentials for Engineers and Scientists

 

[Dec 1, 2003] 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:

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 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.

	The one book you need to study string algorithms	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.
	The String Algorithm Bible?	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.
	One of the best books on string searching and matching	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

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

A Beginner's Guide to Graph Theory

by W. D. Wallis
Amazon price: $34.95

Hardcover - 240 pages (July 2000)
Birkhauser (Architectural); ISBN: 0817641769 ; Dimensions (in inches): 0.69 x 9.51 x 6.41
Amazon.com Sales Rank: 1,095,248

Practical Introduction to Data Structures and Algorithm Analysis, A (C++ Edition)

by Clifford A. Shaffer
Amazon price: $71.33

Hardcover - 494 pages 1 edition (August 12, 1996)
Prentice Hall; ISBN: 0131907522 ; Dimensions (in inches): 0.98 x 9.55 x 7.27
Amazon.com Sales Rank: 184,279
Avg. Customer Review:
Number of Reviews: 5

Schaffer's book does a creditable job of explaining AVL trees but the implementation of the code isn't the greatest.

Above average but recommend others, December 5, 1999
Reviewer: A reader from San Diego, CA
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

Amazon price: $35.99

Paperback - 256 pages 1 edition (September 27, 1996)
John Wiley & Sons; ISBN: 0471149667 ; Dimensions (in inches): 0.65 x 9.28 x 7.54
Amazon.com Sales Rank: 46,571
Avg. Customer Review:
Number of Reviews: 5

Compression Algorithms for Real Programmers (For Real Programmers)

by Peter Wayner

 

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:
Number of Reviews: 4

 

Data Structures and Algorithms in C

by Adam Drozdek

Hardcover 2nd edition (June 2000)
Brooks/Cole Pub Co; ISBN: 0534375979
This item will be published in June 2000. You may order it now and we will ship it to you when it arrives.

 

Leda A Platform for Combinatorial and Geometric Computing

by Kurt Mehlhorn, Stefan Naher

Amazon price: $80.00

Hardcover - 1018 pages (February 2000)
Cambridge Univ Pr (Short); ISBN: 0521563291 ; Dimensions (in inches): 2.23 x 10.01 x 7.95
Amazon.com Sales Rank: 80,450
Avg. Customer Review:
Number of Reviews: 1

Algorithms and Theory of Computation Handbook

by Mikhail J. Atallah (Editor)

Amazon price: $94.95
Hardcover - 1296 pages (October 1999)
CRC Press; ISBN: 0849326494 ; Dimensions (in inches): 2.51 x 10.30 x 7.37
Amazon.com Sales Rank: 74,912
Avg. Customer Review:
Number of Reviews: 3

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. Hardcover (February 1998)

Usually ships in 24 hours

Amazon price:$61.95
Average Customer Review:

Hardcover (February 1998)
Pws Pub Co; ISBN: 0534951236
Amazon.com Sales Rank: 217,316
Avg. Customer Review:
Number of Reviews: 1

	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

 

 

Problems on Algorithms

by Ian Parberry
Amazon price: $18.40
Availability: This title usually ships within 2-3 days.
Textbook Binding - 192 pages 1 edition (February 8, 1995)
Prentice Hall; ISBN: 0134335589 ; Dimensions (in inches): 0.37 x 9.22 x 6.97
Amazon.com Sales Rank: 134,366
Avg. Customer Review:
Number of Reviews: 1 

 Introduction to Computing and Algorithms

by Russell L. Shackleford, Russell L. Shackelford
Amazon price: $53.00 + $2.75 special surcharge

Textbook Binding - 464 pages (October 1997)
Addison-Wesley Pub Co; ISBN: 0201314517 ; Dimensions (in inches): 0.87 x 9.20 x 7.51
Amazon.com Sales Rank: 133,619
Avg. Customer Review:
Number of Reviews: 5

	An excellent introduction into algorithmic concepts.	April 13, 1999
	Reviewer: George Perantatos (zorba1@hotmail.com) from Atlanta, GA.
	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

Amazon price: $64.00
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

Amazon.com Sales Rank: 52,235
Avg. Customer Review:
Number of Reviews: 1

Quite expensive book, the value is unclear.  None of the authors produced any other algorithm-related book...

(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:

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.

Great Ideas in Computer Science A Gentle Introduction

by Alan W. Biermann, Alan W. Bierman

Amazon price: $42.95

Paperback - 568 pages 2nd edition (April 1997)
MIT Pr; ISBN: 0262522233 ; Dimensions (in inches): 1.26 x 8.97 x 8.02
Amazon.com Sales Rank: 90,924

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:
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%)

	OK book. Bad subject matter.	February 4, 2000
	Reviewer: A reader from Austin, TX USA
	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.

	more perl than algorithms ...	December 18, 1999
	Reviewer: A reader
	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

• Softpanorama Classic Computer books

• Open Source Pioneers/Donald Knuth,

• Compiler books

• C books, 

• assembler books

• OS algorithms and concepts books

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 :-).

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.

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:

• a "swiss" version that can be compiled for Linux
• MIXBuilder: an editor, assembler, simulator, and interactive debugger for Win32 platforms, by Bill Menees
• EMIX: an expandable MIX emulator for the Win32 platform, by Daniel Andrade and Marcus Pereira
• MIX/MIXAL in C with lex and CWEB documentation, by Douglas Laing
• MIX/MIXAL package from The Retrocomputing Museum

 

**** 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
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
	Reviewer: 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
	Reviewer: 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 (Editor)

Amazon price: $27.96
You Save: $6.99 (20%)
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:

Horrid Title UnLike O'Reilly

Reviewer: 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
Reviewer: 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 ~ Usually ships in 24 hours

Robert Lafore / Paperback / Published 1999
Amazon price: $19.99 ~ You Save: $5.00 (20%)
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  -- no e-text.

Robert Sedgewick / Paperback / Published 1997

Amazon price: $45.95

Amazon rating: ****

Number of reviews: 9

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 ~ Usually ships in 24 hours

Robert Sedgewick / Paperback / Published 1999
Amazon price: $39.95

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
	Reviewer: 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)  

Mitchell Waite, Robert Lafore
Amazon price: $34.99
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

 

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

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.

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

Amazon price: $76.00

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:
Number of Reviews: 5

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

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:

Hardcover (February 1998)
Pws Pub Co; ISBN: 0534951236
Amazon.com Sales Rank: 217,316
Avg. Customer Review:
Number of Reviews: 1

	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

***+ Foundations of Computer Science (Principles of Computer Science Series) ~ Usually ships in 24 hours

Alfred V. Aho, Jeffrey D. Ullman (Contributor) / Hardcover / Published 1995
Amazon price: $67.95

Amazon rating: *****

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

 

???? Introduction to Algorithms

Thomas H. Cormen / Hardcover / Published 1999
Amazon price: $80.85 (Not Yet Published -- On Order)

 

Data Structures and Their Algorithms

by Harry R. Lewis, Larry Denenberg
Amazon Price: $73.13
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:
Number of Reviews: 4
Table of contents
Too short to be useful for such a volume of material.


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.

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.)


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 ~ Usually ships in 2-3 days

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 o