Algorithms Books

The content should be accessible to any graduate student but the sloppy writing style has made it unnecessarily difficult to read. Out of the many poorly written places, here is an example. In section 6.3.5 on page 248, it wrote, "Recall from section 9.3.1..." But I am only in chapter 6, how can I recall something from chapter 9. I then checked chapter 9 and found out that the forward reference was not a typo.

"Foundations of Multithreaded, Parallel, and Distributed Programming" by Gregory Andrews is a much better written book. Unfortunately, Gregory's book does not cover the same content.

I bought the book a few months ago as textbook for my semester class in high performance computing. After reading the first 3 chapters I realized that this book is a waste. The examples are only solved partially, a lot of jargons (they should have put the terminology in separate table, maybe).

I was hoping, by reading the book I'd learn something essential and got the basic philosophy of high-performance computing/parallel processing. Instead, I got more confused than before reading it! (I used to be real-time software programmer, so the field is not totally new to me). The authors tried to put everything in this small 633-pages book.

Even my professor said it is useless to read the book and refer us to other papers [Robertazzi's papers], and yes, these IEEE/ACM papers are much clearly explained and understood! I also found that a website is much better explaining the concept. Another book is also I guess better: "Fundamentals of Parallel Processing" by Harry F. Jordan and Gita Alaghband.

Don't waste your money on this book.

This book is extremely poorly written. The authors glaze over complex equations and magically come up with answers that don't make any sense. For example, to anyone having taken a prior architecture course the author's are completely wrong in the majority of cache performance analysis done early on in the book. Problems associated with that topic force the reader to dumb-down quite a bit to achieve their "expected" answer.

The user is left in most cases to derive the bizarre math that is involved through the authors' hand-waiving.
One of my personal favorites is from a formula derivation given on page 340, the sequence follows from the text as:

n^2=Ktwnp,
n=Ktwp,
n^2=K^2tw^2p^2, <--what, did I miss something here?
W=K^2tw^2p^2,

On top of that there are numerous typos in the sparse visual examples that do exist. Thus it makes it even more confounding to read through.

If you are evaluating the text for a possible parallel computing course. Don't waste your time or money with this text, your students will thank you. If you are student looking to take a class that uses this text...dropping a brick on your foot might be more enjoyable. If you think I'm a disgruntled student trying to seek revenge, I'm not. I did fine in the course, and I just want to make sure that no one else gets blind-sided by the non-sensical garbage that is this text. If there was a negative rating...this would be below 1 star.

I agree with the other reviewers who have said that this book is sloppy. There are just far too many mistakes for a 2nd edition book; very discouraging in an Addison-Wesley print.

The content is OK, and fairly thorough, but as another reviewer noted, there's considerable handwaving going on in some of the explanations.

Bottom line: a cleaned-up 3rd edition could be a very good textbook. Too bad I'm stuck with the 2nd edition :(

Yes, this is definitely a good book. The discussions on some of the topics are in depth. Parallel algorithm designs are considered from several different angles (mostly from theoretical performance's point of view). One definitely has to get some backgrounds in algorithms before one can digest the contents of this book, thus I recommend this book only for juniors, seniors, graduate students. From the theoretical point of view this book is great, but from the "experimental" point of view is not. It lacks examples and exercises on doing the theory in the actual parallel computers. Thus you have to develop your own MPI (or openMP) understanding and apply it to the topics discussed in this book.

While sparse on the details of many of the algorithms and theorems mentioned, as an introduction it covers a broad range of material-enough for two semesters of study. The writing is lucid, and when a proof of a theorem is given, it is easy to follow and explained in english afterward. Rationale is given for everything, which is a great benefit to a student not familiar with the nuances of sophisticated linear algebra.

This book excels at presenting a reader with little to no knowledge in computer science and a mild mathematical background (knowledge of differential equations as a prerequisite) with the fundamental concepts regarding scientific computing. The presentation of pseudo-code algorithms helps smooth the transition from analytical (pencil and paper) thinking to numerical thinking. The algorithms are presented in a manner such tha anyone with access to dozens of possible environments can apply them, though they are by no means complete, thus requiring some thought into the processes. The material covered is 110% of what an engineer will want to know, 90% of what an applied mathematician will want to know, and 45% of what a numerical analyist will want to know. In all, a great book to begin a foray into numerical computing.

Wow, people seem to be really split on this book. I had Mike Heath for numerical analysis/scientific computing and he was an excellent instructor, one of the best lecturers I've ever had. (As a consequence, I have a hard time separating the book and the class, so judge accordingly.) The book is based on his lecture notes, though he added some material and didn't cover every topic in the book. Just reading the book is useful to give you an overview of the point behind different methods. The goal of the class for which this book was written is actually quite conceptual. It was to give scientists (that's me: a stats researcher who makes heavy use of numerical computation) and CS people in areas other than scientific computing a leg up. It was only a first class for people in scientific computing, the rough equivalent of intro Physics or intro Probability/Stats for people in those respective majors. However, you *won't* be prepared to "roll your own" from this book. In fact, at the beginning of the semester Heath was very careful to note that if you have the opportunity to use a library function for most numerical programming, you are nuts to roll your own. Why? Numerical algorithms are usually extremely complicated and the authors of the code often spend years developing careful expertise on them. Frequently the formulas used to elucidate a given method are NOT the ones used to implement it. You need error traps, tricks to handle ill-scaling and other special cases, etc. These are things that someone who has a one-semester, superficial understanding of a topic simply won't have. So consider the book on the goals it set: it is an overview of a field. If you want to learn more about any one topic, you have to dig deeper and consult references and other works, but this is a good place to start. For this, the book serves admirably.

If you are interested in Scientific computing from the viewpoint of the end user that is the guy who uses the method to solve practical engineering problems then this book is lacking.

Not enough methods in this book to constitute an introductory survey of the field. Every chapter gets heavy dose mathematical treatment, apparently Heath loves his math but for the rest of us it doesnt translate into know-how. Know how to solve equations using computational techniques. Very few derivations to back his mathematical swagger, very few examples (if any) and fewer numerical schemes to solve problems. Many of the chapters receive cursory treatment such as PDE's get about 70 pages of print. Far too little to do anyone any good.

He does talk about interesting issues such as conditioning and error analysis and computer precision and memory issues but it is done from such a superficial viewpoint that one cannot use anything to improve ones code. Not recommended if you want to learn numerical methods even if you have an excellent professor to learn from. His chapter on FFT's was even more abstruse and there was hardly any methods with which to solve PDE's.

I had this for a graduate course in Numerical Methods but ended up using Hoffman's excellent book on Numerical Methods.

If you want to have a solid understanding of numerical computation, this book is definitely the last choice. Many theorems are given without any proof or even intuitions behind them in this book. Even when a proof is provided, it's often far from rigorous. The organization of chapters is the worst I have ever seen, revelant materials are scattered over several different locations rather than put together. Take the SVD for example, it is mentioned in the end of chapter 3, but reappears in chapter 4, which is very confusing. If you are new to this area, please don't read this book. It gives you many many facts without explanations, which I think is not a good way to learn new things. David S. Watkins' Fundamentals of Matrix Computations is a lot better and easier to understand. It also emcompasses many detailed treatments of various theorems. If you have bought Heath's book, don't be sad, at least it can serve as a coaster.

This book is not a how-to-do thing. You will learn why this cypher was created, how it was created it all the details. Not an introductory book. But very worth to who ever want to enter modern applied cryptographic field.

This is the official discription of the Twofish encryption algorithm by the people that developed it. The book gives the direct discription of what they have done, *PLUS* the reasons behind the choices that they made, and the considerations that were involved. The book has a readable style, and covers this algorithm in greater detail than I've ever seen one covered before. This book is a must for anyone planning to implement the algorithm.

This book assumes that you know something of Cryptography, it would not be a good introduction to that topic. (However the main author's book "Applied Cryptography" serves that function well)

Bruce Schneier is the Yoda of crpytography and information security, if you've heard him there's no need to ask anyone else. This book would probably only appeal to the genuinely avid crypto fan, its Greek to anyone else. It is a thorough exposition of the making of the Twofish cypher, the latest attempt to secure information as absolutely as possible. You must be well versed in cryptography to get anything out of the work.

The back cover promises "Step-by-step instructions on how to use it in your systems." This is why I bought the book. However, there are only a handful of pages on "Using Twofish", and none of them have anything like a step-by-step howto.

In case you've been asleep for the past few years, the AES competition is over. Rijndael won, two-fish lost. End of story. This book serves only as a historical artifact depicting Schneier's failed attempt at lasting fame and glory.

Listen to the *real* crypto experts (i.e. the AES judges) and stick with the solution that they've chosen.

The source code in this book is an ungodly mess that I wouldn't wish on my worst enemy. It is a mish-mash of poorly explained macros and pre-processor directives. It would take a divine miracle to get the source to compile (Scheier neglects to go into the details of how to do a build, he just throws the source code at you and expects you to figure it out). Perhaps, then, it's no surprise why team-Schneier lost AES.

This book was just PR for the AES competition. Now that it's over, the only thing this book is good for is to prop a door open.

This is a great book for the reader interested in learning a collection of graph algorithms. Though the C code isn't very clear, the text makes up for it with concise well-written explanations. And the figures do an excellent job of illustrating the execution of the algorithms.

But the problem is that it's not so great a book to study the properties of those algorithms. Most theorems are way too dense and the author relies too much on English explanations, when algebraic expressions would be a lot more explanatory. Sometimes the reader gets a sense that the author is hand-waving instead of giving proper proofs.

As students in Robert Sedgewick's Algorithms and Data Structures Course at Princeton, we had the privilege of reading Part 5 of Algorithms in C in a preprint edition this spring. Its treatment of Graph Algorithms is as thorough and comprehensive as the treatment of sorting and searching in parts 1-4. The algorithms discussed range from the fundamental (Depth-first search, Dijkstra's algorithm), to the relatively obscure (Gabow's strong component algorithm), to the impossibly difficult (Network Simplex), all in great detail. The book also discusses real-world applications of these algorithms, such as arbitrage. It contains a good number of useful diagrams allowing step-by-step traces of the algorithms, which helps decipher the sometimes cryptic code.
A warning: the book is DENSE. It is packed with detailed information and can be a difficult read, especially the mathematical analysis of the algorithms.

All in all, a great book, though.

I bought these two book for one reason: to get help implementing algorithms. Since there is lot of code in these books, I thought this would be a good pick. I was wrong. The author is consistently leaving out details vital to understanding the code. He also makes a big deal about abstract data types. This is gloriously of the case. If the readers are supposed to understand the code, transperency would be a more intelligent goal for the author. There are no comments in the code what so ever (yes, this is actually true, not even in the on-line code). The on-line code to this book is a total mess. You would be able to implement all the algorithms from scratch in less time than it would take you to try and piece together the code the author has left for you.
The pity is that there are very few other algorithm books that have real code. Demand a new edition from the author and don't by this one unless you can avoid it.

Robert Sedgewick is certainly well known to all people involved in the development of algorithms form different fields as an author of a number of books about algorithmic methods and data structures. And I am sure that we all appreciate this work because one simply needs all the time a reference to look up not only how one can solve a probem algorithmic but also how one can do this in an efficient way.

This book provides a good overview of algorithms dealing with graphs but the problem is that the connection between the given source code in C and its general exlanation failed. It is clear, that a solution to a problem does not depend on the underlying programing language, hence, Sedgewick's book is anyway not intened to do this otherwise it would wear another title. On the other hand, an algorithm without general explanation brings not much.

I think this book has a conceptual problem. None is interested in preimplemented code, because one normaly has a certain problem the algorithm has to be adapted. In general, this book is better then nothing but far from being a complete source of information concerning the functioning of the algorithms.

I took a data strutures course that used this book. First you have to know C, not C++. You will be dealing with structs not classes. Know your pointers very well. The algorithms are covered are the general ones found in most textbooks dealing with algorithm analysis, but the examples provided are not complete and very vague. You have to rely completely on your instructor to spoon feed you the explanation and if your instructor sucks, then you are out of luck. There are much better textbooks, that take the time to give full explanations of the various interesting data structures out there. God bless and good luck to you if you are using this one for a DS course.

I gave four stars because the author did a very good job of explaining algorithms. For example, he did a fantastic job of explaining the conversion of Infix Notation to Postfix Notation. Very nice to see a graphical step-by-step approach. Another good area was his break down of explaining how to derive the solution from a postfix equation. Again, nice usage of illustration step-by-step. I did not understand other author's datastructure book, but I did understand this one. I picked up this book only to learn Polish calculators (postfix/infix). Therefore, I did not read the other chapters. If the remaining chapters are as easily understandable as these two chapters, then I'll give 5 stars.

This book is not meant for the beginner and intermediate programer. The author intended this book for the elite. Don't buy this book if you don't have a background in Discrete Math or have Master the c language. Wouldn't not recommend this book to colleges who have a Data Structures class for undergraduates. The code in the book assumes that you can piece together the individual functions to write a full program in c. Also There is no problems that a student can try on his/her own and then find the answer in back of book.

this book provides a concise and fundamental look into algorithms. Excellent book if you want to learn performance time and running time on your written code and gives you the technique to speed up your code. It does not focus too much on what kind of programming language you use and it is to be read in a general sense.

These truths I hold to be self evident:
1) It is unacceptable to provide equations without explaining all the symbols in them.
2) If you explain something to an intelligent person and they still don't understand then it is your fault not theirs.
3) Laziness is the right of the reader, not the author.

In practice you assume your audience knows some things, ellide from previous equations for space and fluency, and provide a glossary. But I have a degree in maths (not stats) and still I can't make head or tail of the first two pages of chapter 2 in the excerpt given. So I will look for a book, article or course that assumes less knowledge on my part.

I tried to read the whole introductive chapter a couple of times but I couldn't understand what is EM about, the used terminology and the basic definitions. The authors say that the book is for theoriticians and practicioners, but I do think it is not appropriate for both categories, unless the reader has been involved in writing papers on this topic. I have enough background knowledge in probability theory and in mathematics but it seems that I have to read all the relevant literature before going a step ahead. In my opinion this book is wide useless for people who do not know EM algorithm.

Geoff McLachlan is well known for his books on discrimination and mixture models. He is an excellent writer who is very thorough in his description of the literature. The EM algorithm is a great invention which dates back to the seminal paper in JRSS by Dempster, Laird and Rubin. It was originally devised to handle likelihood estimation in the face of missing data. Standard applications also include truncated and censored data. Clever application of the missingness in the data structure have allowed it to be applicable to mixture model estimation and other problems where the missing information is not so obvious. It is used for Bayesian estimation, image processing, in random effects models, latent variable structures and log linear models. The technique and its applications are covered in parts of various books on specialized statistical topics or on statistical computing. However, this is the first and only text that is dedicated to the algorithm itself and its wide variety of applications. It is a perfect reference source for the EM algorithm and its various modifications. It provides a thorough and unified treatment for the subject.

Excellent text on the EM algorithm. Covers theory as well as a number of applications. Clearly written. Historical accounts and examples make reading delightful. I would have found it sweeter if it covered applications in time series. It was only inevitable that everyone's favorite application couldn't be included because of their sheer multitude.

I guess this is also the only text available on the subject, as of now!

If you are looking for practical applications of this kind of algoritmicts do not buy this book. The 50% of the book are data tables, it would be better buying a cd-rom with all those data and the book had 200 less pages. A better choice than this book is "Trading on the edge" or "Neural networks for finance".

For a project decision maker trying to evaluate the genetic algorithm approach, this book helps to understand the main concepts. It is a great for anyone who wants ideas to help evaluate the potentials and shortcomings of a GA system without getting mixed up in the math and details. It includes comparisons to chaos theory and neural nets.

For programmers looking implement code, or data administrators looking for the right data feeds, however, this book might be a frustrating tease. The book is full of examples such as mentioning the selection of "10 parameters from a possible 150 macroeconomic variables", but never says what the parameters are. The book is still useful. A little patience with this book might yield some great ideas although the author didn't directly communicate it. Never the less, just one small idea could easily pay for this book many many times over. For the pure IT developer, I highly recommend "Neural Networks in Finance and Investing" by Trippi & Turban instead which includes documented code and examples on a disk.

The author presents a general introduction into ga's , then moves over to investment strategies and presents solutions.

Unfortunately, he does NOT give background information on the really interesting things like string patterns used, crossover and fitness function and the like. Futhermore, more than one third of the book is filled with endless tables whose content the reader understands after the first table. I guess it makes for a larger book.

conclusion: very disappointing.

After I read this book I read the review from 1998. I was quite surprised that the prior reviewer felt that way. The book provides an introduction to developing the data required for testing, a methodology for developing a study that would be useful in investment practice. This is a quality effort. This book will not provide (or promise) the reader a turnkey system for conquering the market, however there is a framework for future research.

This book was written in 1994, before many of the books dealing with Neural Networks came out, and so the terminology will seem unfamiliar. If you are willing to work through these differences (and it is not too hard) then there is a great deal to learn here.

Bauer predicted (in 1994) that Genetic Algorithms would become widely used. Bauer also predicted that much of the development would be done in secret. I have not come across them in the last few years and at very least I would have expected to see them as signals for sale from system developers. Additionally, there are a series of books like this one that should have appeared since 1994. A search of Amazon using Genetic Algorithm as the subject and sorting by publication date returns 133 titles. I reviewed these titles and did not find any further investment focused titles. I will use this book as a starting point for my research.

My next book will be Melanie Mitchell's "Introduction to GAs".

Page after page of MFC code that should not have been in print, but rather in the accompanying CD. Not enough text and very shallow on dealing with the subject at hand. There are small introductory web pages that will teach you more about GA and their C++ implementation than this book will.

This is an excellent introduction to genetic algorithms. It is best if you know a little bit about software but the book is so well written that even someone who knows nothing about programming will be able to grasp the basic concepts. I had never heard of genetic algorithms before reading this book. When I tried the first "black box" program I was amazed at how quickly the GA found the solution. Seeing evolution in action had a profound impact on me. If some fundamentalist creationists read this book, and saw how natural selection can be used to find creative solutions to difficult problems, it might open their minds to Darwin.

This book deals with a wide variety of intersting and practical topics such as random number generators and finite state machines. I found the section on robotic ants to be the most interesting. It almost makes you wonder if it is possible to create life in a computer (I guess it depends on how you define life).

The only minor complaint I have is that the examples are written for Microsoft Windows which means that the code is cluttered with a lot of GUI garbage. I would have preferred plain old C or C++ or even pseudo code.

I found this book to be a disappointment. It was hard to follow and lacked explainations in some areas. Too much space was spent on random number theory. Don't let the title mislead you; the source code requires C++ with a visual framework (OWL or MFC). I've seen better; skip this one.

The introduction to the basic concepts of GA's was hard to follow, compared to others I've read. In addition, there were several typos and a paragraph that ended in the middle of a key sentence. Also, I would have preferred code for a console app. IMO, the visual stuff just gets in the way of understanding what's going on.

This is my third review; my two previous reviews have been removed. I have already notified Amazon about this fact

As I have stated, book is just a printout of Java program, without any explanation how program is doing what is doing, what are program limitations in terms of memory, time and complexity. Programming style is mostly Fortran IV like. Programs are without single line of comment and with non-intuitive variable names, what makes modificatios difficult or impossible. Book can be useful for somebody who needs "black box" library, doesn't need to understand programs and trusts the author that programs fave no flaws

There are many well-written textbooks that cover the theory
and algorithms on graphs and combinatorial optimization.
Very few provide the computer code for the methods. This
book offers an extensive collection of Java programs in
this area. Each program is self-contained and can be used
independently through parameter passing. The drawback of
the book is that the coding style is not object oriented,
and the programs would be difficult to maintain. The
description of the methods and their implementations is
terse. Hence the book is not intended as a learning text.
But the library of programs is a very convenient handy
device for students and researchers in locating solutions
to classroom didactic problems in graphs and optimization,
which apparently is the main objective of the book.

This library of ready-to-use programs is extremely useful. I have used the programs with very minimal effort in obtaining solutions to some graph optimization problems. Unfortunately the programs are not well documented; it would be a challenge to make modifications to the code. However, the library serves as an ideal black box tool in solving most of the pedagogical graph theory and optimization problems, especially well suited for users who are not of much concern for the underlying methodology and implementation.

There are so many problems with this book, it's hard to know where to begin. So I don't come across as all and only negative, I will first give it credit for gathering together, at least in name a large number of graph processing algorithms.

That said, here are the problems:

The book is just a catalog of graph algorithms with poorly done documentation and even worse actual code. To wit:


*Each algorithm is preceded by a very brief explanation of what it does and some of the issues involved. Suffice it to say that it's the sparsest and most minimal explanation imaginable; if you don't already understand the issues involved, you probably won't after reading the short paragraph or two that precedes each algorithm / method.

*There is but ONE class and every bit of functionality is contained in its own individual, single static method. This "design" causes not a few of the methods to literally run to a thousand and more lines and contain dozens and dozens of (cryptically named) member variables.


So for instance, if you are interested in planarity testing, there's a "method" called planarityTesting that takes four parameters and returns true or false.

All well and good until you actually look at that method and see declared 51 , that's fifty-one, member variables. Each of these variables has poorly chosen names like, "wkpathfind2" and "store2" and "store3" and of course "store4" and "sortptr1" and "sortptr2". I thought this tactic of vowel-conserving naming of variables went out with the 8 + 3 DOS naming convention. At any rate, the cryptic naming scheme combined with the lack of javadoc combine to render each variable's purpose completely opaque. This makes it all but impossible to relate the code to the underlying graph theory.

Then comes the code.

Imagine a thousand and more lines, literally page after page after page of streaming code, all one single method, manipulating these cryptic variables in virtually uncommented ways.

That is pretty much what you get with this book. One algorithm after another after another.

I would say the following:
1) the author codes as if from another time. There is NO object-oriented design to this code whatsoever. None. Zero. Zip.

2)The methods are hundreds or thousands of lines of what amounts to undocumented symbol manipulation. There is small chance to learn anything from this book with respect to relating the code to graph theory.

3) I can say that, having implemented many of the algorithms in this book myself prior to buying this book, the book has contributed nothing to my understanding and further, that already understanding the issues surrounding many of these methods, that is being a qualified reader, is NOT sufficient to allow the reader to follow and understand the algorithms.

4) If you only want to use the (static) methods to return a value or ascertain some property of a graph and you don't care to understand how it works or why it works, then perhaps you'll be happy with this book, but then , why not release the object code as blackbox library? If the code was never meant to be read, and there is no attempt at explaining graph theory as it relates to the code, then what of value is left for the reader?



5) Finally, if the purpose of the book is deliver a good "black-box" library, readers should know that the actual implementation of the graph "object" chosen in this book makes will make that problematic. The book uses an adjacency matrix to represent the graph, a well known data structure in graph theory. Unfortunately, this data structure has the following well-known problem: it is only suitable for the rare instance of dense graphs. The runtime performance and memory demands of this data structure make it unsuitable to any but very very small graphs. Most graphs are neither very very small nor very very dense, (as dense is defined in graph theory), and for that reason almost all graph drawing packages opt for a linked-list data structure to represent the graph.

This is solidly the worst book on this subject I have yet encountered. Amazon offers a number of alternative books, including the fine Graph Algorithms, Third Edition by Robert Sedgewick and Michael Schidlowsky, a book I have no connection with whatsoever and two authors who are otherwise unknown to me. Bundle of Algorithms in Java, Third Edition (Parts 1-5): Fundamentals, Data Structures, Sorting, Searching, and Graph Algorithms, Third Edition

I fully agree witht the previous reviewer. In an attempt to make things look simple, the author forgets that the objective of a good technical and engineering book is not to be just a cookbook for your kitchen where there are no deep whys, but to make the reader actually understand what is going on under the hood. This book fails completely at this, assuming you can reach the end survyving the frustrations, you will not remember the rationale for any single step taken.
A much better choice if you really want to understand the subject are Blahut's and Todd Moon's books.

The book attempts to provide a practical perspective without getting into nitty-gritty details of the theory behind error correcting codes. This limits its usefulness of you wish to understand FEC codes and how they work. Worse, its practical treatment has gaps as well, and one is left without the understanding that's needed to fill in the gaps. I went to study the C program for BCH codes in the companion Web site as well: its represents a sparsely commented "point solution" for a very specific code of short word length and is based on sophisticated methods that, while no doubt highly efficient, are only very thinly treated in the book. This makes it very difficult to understand what the program is doing, let alone to generalize it to other flavors of the code. I have found Shu Lin's and Daniel Costello's book "Error Control Coding" to be much more useful.

This book is a great introduction to the topic of error correcting codes. It gives very simple examples to demonstrate the main concepts of coding and decoding for error correction. The part on iterative decoding needs more work. However, the exposition of Reed Solomon codes and their decoding is outstanding. I definitely recommend this book!