Algorithms Books

This is a very useful book. It starts by introducing very important and interesting techniques in optimisation i.e. genetic algorithms, simulated annealing, tabu search and neural networks. It continues by giving examples of how the techniques have been applied in various case studies. The book also contains code so that users have a head start in implementing the techniques described. This book is good for beginners because it describes the basics of the techniques. It is also suitable for more advanced researchers because the case studies provoke ideas for further work. In conclusion, this book is a useful addition to the bookshelf of any researcher interested in intelligent optimisation.

I bought this book because it has source code for simulated annealing, genetic algorithms, tabu search and neural networks.
I have used the three first source code and ... they are so buggy.
They're wrote in C but doesn't compile due to evident syntax errors (so evident, are they here so as to made these source code unusable ?).
The content of the book is not equilibrate (some metaheuristics aren't discussed thoroughly).
If the authors use there source code, I think evereything presented in this book is completely false.
Don't buy it, there are some better books to buy.

This book gave a superficial coverage on 4 optimization techniques in Chapter 1. Out of the 4 techniques, only Genetic Algorithm was explained slighty more in detail. The rest are merely short examples. That is about all you will get from this book (one brief Chapter on ALL 4 techniques).

The author has the knack for taking a simple topic and hiding it in a wordy description. It's too bad there is not a negative star rating.

I didn't find it that bad ! At least not as bad as it was previously reviewed. There are some good examples and the theory is well explained.

I took a full two semesters of Computer Science from the professors who actually wrote this textbook. The course was easily one of the worst I have ever taken in university and I could spend pages detailing how much I hated it, but instead I'll simply talk about the book.

Data Structures and Software Development in an Object Oriented Domain attempts to introduce students to the concepts of Software Engineering, as well as expanding upon the theory and application of various data structures AND all the while explaining the Eiffel programming language, and therein lies the problem. Quite simply, it bites off much more than it can chew. The textbook is massive; over 1000 pages, with the words packed in tight with a teensy-tiny font making it hard to read. Every chapter goes into a ridiculous level of detail that would never be covered in class, even through two semesters. The sheer information density makes for difficult reading, especially when trying to extract the essentials. Some sections border on incomprehensible simply due to the density of the material...so much so that during class, the professor actually photocopied and clarified the material from his own textbook as handouts! The general exposition itself is incredibly dry and unintuitive, and you'll find yourself skipping over pages and pages until you find whatever it is your looking for. I don't think I'm exaggerating when I say that half the material could be thrown away. Clear and concise it ain't.

Compounding this problem is that the chapters are poorly laid out and do not flow logically. Sections as diverse as timing anaylysis, arrays, binary trees, implementation of abstract data types (ADTs), etc. are thrown about willy-nilly. The Data structures bits are mixed in with software engineering bits, making for disjointed reading. As if to acknowledge this problem, near the beginning of the book one finds a nonsensical schematic of each chapter's "prerequisites". Why this was done instead of simply arranging the chapters in a more logical order is beyond me.

Data Structures and Software Development in an Object Oriented Domain is a ridiculously bloated and expensive textbook that I would never recommend, but like most college texts you will have no choice in buying it. Buy it, and then sell it the day classes are over.

I had the pleasure of being one of the test audiences for this particular book. I'm basing my review on my copy, 1,000+ pages of photocopied draft. I was introduced to it via a full-year course taught by Dr. Temblay and Dr. Cheston.

The book is basically about a couple things: Writing superior Data Types via OO processes and an introdution to OO developement.

The section on datatypes is very good. The datatypes are constructed using string OO processes (the cd contains all the code for the datatypes created in the book) and are a good learning process. There is an emphasis on abstraction and generics in the design which is an intelligent way to do things, and I learned a lot about datatypes and OO through this. The section on formal ADTs, however, I found incomprehensible, but others may have different opinions.

The authors do focus on important OO concepts like UML and use cases, the brief section on software design suggests using the waterfall method. This section is fairly good, and is a decent introduction for a subject that can be fleshed out in further classes. It is still introductory however. For instance, patterns are not heavily mentioned, nor other development practices.

Other ideas focused on were mathematical induction, a strong section on testing, sorting theory and files as well as algorithm timing and reccurence relations.

This is a good book, and most undergrad students could likely learn a lot from it, assuming they are willing to spend a little time learning eiffel.

This book, Fundamental Ephemeris Computations, is authored by Paul J. Heafner, but the previous reviewer, who wrote a very glowing review, is talking about the book of Jean Meeus. And 5 out of 9 persons found the review helpfull. What's the matter here?

It's amazing how accurate the calculations are. Strictly speaking, we just want to have the positions more or less of the planets e.g., but Jean Meeus goes so far, he even takes the speed of light in account, delivering results with an accuracy beneath the arcsecond. However, the book is the only one in is kind and explains the formulae needed for the positions of all solar system bodies, including comets and minor planets. How difficult Jean Meeus goes doesn't matter, because he made the book easily reading. Corrections including nutation, aberration and recession are more comprehensible than ever. The book is a must for the amateur astronomers who also know how to build programs to simulate the movements of all lights at night. Specially because Jean Meeus starts the book with all possible surprises you meet when using floating numbers. You will never regret it.

Don't waste your money (and time) on that ancient book.

It's shame to offer a 70's book for regular sale! Although it reprinted again in 94, its content remain.

It is a very usefull book for an computer engineer.If you are in a first class of computer engineer you can have some difficulties about using the mathematical formulas in computer.This book makes you learn yery easy.It is for a starter.

I have never received this product and every day it shows USPS picked it up on the date of that day. Apparently there is no other way to report this kind of problem within the Amazon website, since my search of "Complaints" yielded no relevant content. I ordered this book back in mid-January. It was supposed to ship by Jan 23 with an expected delivery of Jan 28. Needless to say this book is effectively worthless and I question its continuing existence.

We all want better compression. Yet surely the current JPG and GIF have taken us to the limit? Apparently not, if you read this book. There is still some slack that can be squeezed out of an image, if you use JPEG2000. Acharya gives you all the technical details. Where it would greatly assist your comprehension if you already knew about the discrete cosine transform and the current JPG standard.

The book also shows how VLSI chips can be designed to perform hardware JPG2000 computations. Why? As the book explains, think of many consumer electronics devices, like cameraphones. Perhaps you can help bring this about?

But one has to wonder how much longer this can go on. There must be a point of diminishing returns in the cost of computations versus the gains to be made in compression.

I am a student of Mr Brunskills and he recommended this book to me. I was totally conned. Its content is, well, lets just say lacking. It is O.K as a guideline but its basically just lecture notes bundled together and sold as a product to students who can barely afford it. Total Waste of Money.

I think that this is a very good book for any computer algorithm university student, buy it!

This book gave me no hope for Analysis of Algorithm and Data Structures class, i have yet to find another book to assist me in this area. the book was so-what easy to read, but the explanation of the concepts is really horrible, dont waste ur money

I would not reccomend this book for learning about data structures. With incomplete code and scampy sections on core area material, it seems to serve more as a workbook than anything else. In addition to this I find it to be poorly worded which has often caused me to overlook important details or have to read a sentence multiple times to understand what the author is saying. What saves this from being a one star product is the fact that if you do know the material, it can help you review structures but even then, the ackward wording still can slow down a quick read.

Dr. Shaffer attempts to address the difficult topic of data structures and fails. Consistently he glosses over important points, or does not describe the implementation of data structures (the buffer pool, for example, is especially poor) adequately and leaves the hapless student confused and frustrated. For a computer scientist who already understands the subject this book may contain a few good points. Indeed, I was able to follow the sections where I had previous training, but when I studied material new to me, I was out of luck.

If you are unlucky enough to have a university that uses this text, consider trying to find a better book to get yourself an adequate understanding of this important subject, because Dr. Shaffer's text won't do that for you.

I have Dr Shaffer as my professor and he is just as boring in real life as his book. He has told us that some of the code segements are broken to make his students figure them out. DONT buy this book... It's not worth the money.

...but this was a mandatory book for my university's two-course Data Structures & Algorithms sequence that all computer scientists and computer engineers must take.

Coming in with a good deal of programming experience, I find that this book is not as clear or as complete as it could be. The sample code snippets throughout tend to be awkwardly implmented with obscure variable names and obtuse datatyping, and more often than not represent 'a' way of accomplishing a task rather than 'the best' way. Finding better ways of doing things is normally left for exercises at the end of the chapter; the answers are not included with the book.

Also, many significant details or comments are skimmed over or are ommitted from the text. Many important (and complex) observations are left as exercises - but again, the answers are not included, so there is no way of validating your answers.

Further, this book is targeted at the C++ language. It is obscene to discuss data structures and algorithms without mentioning the free, prepackaged, and optimized code of the C++ Standard Template Library. Indeed, this book and the code it includes would have benefitted from the ingenious architecture and software engineering behind the STL.

I really hope the campus bookstore will buy this one back when I'm done with it.

This textbook is a mess. It is not elegant or clear, and their coverage of certain topics is confusing and deviates from standard practice. If your algorithms class is using this text, find some friends to pool together and get a copy for the exercises if they are used, otherwise take the book from MIT by Rivest et al out of the library and read that.

Introduction to Algorithms

I would have rated "0 stars " if poosible in the selection.
Since this is the textbook for my course I have to deal with this book. The way things are mentioned in this book I doubt whether the authors have even understood the concepts right. I think that the authors themselves are confused while writing this book.
If this book is for your course, drop the course before it is too late.

if so,it's very pity ,because it is the textbook of my Algorithm class this term.

An appalling book.
Boring, poorly written, poorly edited.

Try Algorithm design manual by Steven S. Skiena or Thomas H. Cormen's Introduction to Algorithms or Kleinberg and Tardos'
Algorithm Design or the excellent Introduction to the Design and Analysis of Algorithms by Anany V. Levitin instead of this mish-mash.

This book is in a word, bad. The explanations of the algorithms are decent in places but in some areas using the pseudo code provided you could not reproduce a working algorithm. What data structure they are using is sometimes difficult to determine. They also use function calls they do not explain. When reading the book they are constantly referring back to things they talked about chapters ago just by giving an "Algorithm" or figure number. But with the Lemma and definitions and Examples having similar numbers you will spend a lot of time looking for it, how hard would a page number be? Over all I am not happy.

On the plus side the math review at the start of the book is decent and the book is not too wordy.

I have 4 books on algorithms and I still have not found one that I really like, a shame. This book attempts to be a modern update to "The Design and Analysis of Computer Algorithms" -AHO | Hopcroft | Ullman. An update of that book is not what students need. They need a rethinking of how to present algorithms. We are still waiting on that book.

This is a not so good book, but our school uses it. I suggest the author to update some of the contents of the book.

Albeit the author, Randy Chow, may have meant well in writing this Book, good intentions alone do not produce good books. The author claims that there is a need for a Book that balances theory with implementation. It is questionable whether Chow's Book accomplishes this synthesis but, unquestionably, terribly fails to provide us with reading of any intellectual usefulness. The Book is written in a style that could best be described as choppy, redundant, and overly simplistic. Further, the author seems to inundate us with his own interpretative viewpoints many of which are incorrect. The author should have spent more time in intensive communicative therapy expanding his vernacular of the English language before attempting writing a Book on this difficult subject. My recommendation is steer clear of this book and rely on the preexisting library of texts on this subject matter. That way you will at least not expose yourself to Randy Chow's further pollution of the English language, something that can very easily become contagious in a teaching environment. One must believe, that the University of Fl., where Mr. Chow teaches, is causing students to become mental midgets because of such poorly written textbooks which now seem to plague the Computer Science discipline. There is clearly a need to discourage mediocre faculty from authoring and inundating academia with such poorly written texts. Chow's preface gives all the reason and adequate forwarning not to purchase this Book. The preface clearly exhibits Mr. Chow's atrocious writing style which plagues the entire Book. Randy Chow's intellectual dwarfism is not that he attempted to write a Book, but that he failed to recognize he has not sufficently acquired the writing and intellectual skills needed to write a book that could be of any usefulness. I encourage Mr. Chow to attempt to write the same Book in his native tongue of Chinese though I doubt that even in fluent Chinese this would be a useful Book.

The best way to explain this book is, its a "good rough draft". Now go work on it some more. As is, the book is extremely hard to read. Crucial concepts are stated matter of factly, succinctly, and with little detail as possible, ie, just enough to get the point across (and that might be a stretch). The authors could make this a very good book, but they need to take much more time with every subject, and give more than one example. Furthermore the diagrams are sub-par. These diagrams could be greatly enhanced by professional technical artists. Also, the 2nd half of the book might be better interspersed with the 1st half. A *much* better read, with better diagrams, and a gentler approach on the exact same subject is "Distributed Operating Systems" by Andrew Tannenbaum.

I bought this book expecting that I can learn some fundamentals on distributed systems and algos. The author touched many areas - but even stuff that I know pretty well ( security ) wasn't explained in an easy-to-understand manner, sometimes too much prose to no avail. Even worse, sometimes I was a bit confused. I can only guess that the rest follows this way. If you are looking for GOOD book, better look for something else.

This book is probably useful only at the University of Florida, since it follows the course lectures exactly - and that, because the first author is the instructor.

The book reads like a series of lecture notes, nothing more, nothing less. Several ideas that a student of operating systems may need to take note of, when making the transition from single-machine systems to multi-machine, are listed here. You can think of this book as a listing of a few basic ideas, with small expansions of each - as in a slideshow presentation. The merit of the book ends there.

The topics covered - in other words, the expansions of the listed ideas - are treated in a confused, sketchy manner. The material is insubstantial and hardly thought provoking. Motivation is absent, and pedagogical methods seem a distant concept. There is a near-total isolation of concepts and practice, and reading the book gives the feeling of being isolated in a dreamy sphere that belongs only to the author.

One could go on about such demerits, but to summarize, you don't need to buy this book unless it's required for your class. It's a slideshow in hardcover format.