|
Softpanorama |
May the source be with you, but remember the KISS principle ;-)
|
| 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 |
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.
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 |
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... |
|
|
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.
The book also covers some classic algorithms like Searching&Sorting (Ch.8), Basic statistics (Ch.9) and Binary Trees (Ch.10) and probably can be used as a intro "Algorithms and Data Structures" textbook.
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.
Above average but recommend others, December 5, 1999
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:
|
|
|
|
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.
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!
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 | ||
(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