Softpanorama
(slightly skeptical)
Open Source Software Educational Society
May the source be with you, but remember the KISS principle ;-)
Softpanorama Search
|
Softpanorama |
May the source be with you, but remember the KISS principle ;-)
Softpanorama Search
|
| Introductory | ||||||
| C++ based books | C | C++ | ||||
| OS_related algorithms | Compression |
Compiler-related /Program Graphs |
Graphs | Combinatorial, string searching and matching | Sorting and searching | 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 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
|
You can use Honor System to make a contribution, supporting this site |
Based on 22 reviews.
Write a review. 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
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
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
|
Get you started on good programming style, March 2, 2000
|
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
|
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.
T he 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.
What it says, it says best., August 17, 2003
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.
Schaffer's book does a creditable job of explaining AVL trees but the implementation of the code isn't the greatest.
Reviewer: A reader fromSan 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.
| 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 |
|
|
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 | ||
Introduction to Computing and Algorithms
by Russell L. Shackleford, Russell L. Shackelford
Amazon price: $53.00 + $2.75 special surchargeTextbook 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.
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.
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
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
(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!
 |
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 recommended for better choices
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.
(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. | ||
Plus more than a dozen articles related to algorithms from Dr. Dobb's
Journal!
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. | |
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:
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.95Forget 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.
This was an excellent non-academic book on data structures, December
9, 1998
One of the best Data Structures books around, March 31, 2000As 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!
Definitely one to consider, June 8, 1999
Reviewer: A reader from
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.
I would prefer pseudocode based books, but your mileage may vary.
|
|
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 | ||
Great introduction to the subject, wonderful teaching.., March
8, 2000
One of the best books of its type, February 1, 2000(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
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.
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.
See also ../Lang/c.shtml
Reviewer: Jia Jiang (see more about me) fromProvo, 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.
Invaluable for "teach yourself" people., March 16, 1999
Excellent Book, June 26, 2000
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
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:
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)
Must read book on Data Structures, June 14, 2000
Reviewer: appan (see more about me) fromU.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.
.
Number of reviews 1
Best book to learn data structures, April 11, 2000Publisher page Data Structures with C++
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.
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.
Difficult reading, but Excellent Code, August 2, 1999I'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.
Academic in nature and not for the beginning programmer, September
24, 2000The 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 does 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.
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.
based on 16 reviews. (Write
a review) 
MAP
makes many promises, but fails to deliver., August 18, 2003I 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.
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
An engaging and useful text on an important topic., June 12,
1999Kreher 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.
What it says, it says best., August 17, 2003
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 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 | ||
Contents:
Foundations; Disjoint Sets; Heaps; Search Trees; Linking and Cutting Trees; Minimum Spanning Trees; Shortest Paths; Network Flows; Matchings.
Reviewer: Tom Morrisette fromNew 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.
Reviewer: A reader fromSan 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.
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:
Number of Reviews: 3
Thorough, March 24, 2000
Combinatorial heuristic algorithms with source code, September
17, 1997- 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.
** 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 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.
|
|
a book which has its positive and negative sides... |
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 compression |
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. | ||
|
|
The best book for programmers needing algorithms not theory. |
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. | ||
|
|
Misleading ... |
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. | ||
|
|
Many algorithms included, but no in-depth discussion |
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. |
||
|
|
A detailed reference guide for programmers. |
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. | ||
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. :)
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 .
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
|
|
An easy-to-read, for-all-readers algorithms book |
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: | ||
|
|
Just a great book ! |
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. | ||
|
|
Excellent book,although very theoritical |
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 | ||
Copyright © 1996-2009 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. Submit comments This document is an industrial compilation designed and created exclusively for educational use and is placed under the copyright of the Open Content License(OPL). 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.
Disclaimer:
Last modified: August 15, 2009