Algorithms Books

I found this book very helpful in gaining a deeper understanding of what the tools I use are doing. Also, the terminology that is used and explained allows me to easier communication with the CAD developers. I found the information relating to clock skew and jitter of particular value to my daily work.

I read the Chapter on clock routing and found that the
author did not do a good job on explaining about DME
algorithm. I got more confused after reading it. So,
I went to the library and checked the references
which gave me clear understanding. Usually, a book
shoud give a reader with a very clear example about
the algorithm it presents. It's was not the case for
the DME algorithm.

This book is good at introducing basic concepts, if this is what
you want to know. But it is really bad to introduce algorithm.
It simply confuse you. Many time I don't know what the author
is talking about and have to find the original paper, which is
much clear.

Very comprehensive in VLSI physical design automation. People who major in Computer Science and want to study in VLSI is suitable to buy this book. Also people who want to develop EDA tools can buy the book.

I just finished a semester at the University of Texas at Austin in which this book was the text book for an abstract data types class. The book is a good textbook, but not a good desk reference.

The book is obviously written with students in mind, using rhetorical questions, leaving vital areas unexplained as "exercises for the reader", etc. As an introductory text, in an introductory class, the book served its purpose, though the professor was required to explain some of the details that the book lacked. The code that is included in the book is all written in pseudo-code, most of it does not compile without some tweaking, and when a student is trying to grasp a diffucult concept in graph theory, the last thing that student wants is to have to trace through the program, line-by-line, to catch some error that is irrelevant to the larger problem, such as semicolons that have been left out, unmatched parenthesis, variable names that are not allowed by most of the commercial compilers.

The book does have a good learning curve, however, and makes for good reading when first approaching a new computer science concept; however, when having to program a particularly hard section of a certain data structure, wading through pages of diatribe against older methods is not what is needed at that time.

For instance, after spending a large portion of an entire chapter on AVL trees, Weiss proceeds to give example code (that doesn't compile on Borland 5.0, Visual C++, or GNU compilers without some tweaking), but leaves out a crucial method! When first learning about AVL trees, one of the lessons that was drilled into our heads was the diffuculty of AVL deletion... yet the book summed it up in *one* sentence: "As with most data structures, deletion is the hardest task; it is left as an exercise to the reader."

Argh.

Tries to cover all topics but leaves many details that are needed by a beginner. Examples of code are difficult to comprehend.

This book should be on every C++ programmers list. Of all the books I've read on Data Structures and Algorithms using the C++ language this is the most comprehensive. This book also built my knowledge on the C++ language. I look forward to reading more books by this author.

This book is very thorough, but thats really all I can tell you about it's content, because the material (both the algorithm analysis and the data structures material), is presented in such a way as that the author expects you to already have a basic understanding of these concepts. Worst yet, the author's code is extremely poorly documented. Stay away from this book if you are new to advanced data types or algorithm analysis.

This book isn't intended as a master diagnostic manual. You'll almost never get a definitive differential out of it, and most of the information is quite brief. It's supposed to be that way. It helps you look at a symptom and quickly get an idea of where to go, what to do next, and what the problem could be. It's essentially a quick start to sending you down the right path when working through cases. If you're involved in a PBL curriculum it's a great help when you have basically no idea what's going on.

The title of the book is an eye catcher, however it would be nice to actually see an true example of what information is presented in the book and how.

Common Medical Diagnosis is a wonderfully helpful book for members of the medical profession at any level. The clear well written algorithims lead to extensive lists of differential diagnosis allowing the reader to be presented with numerous options. Begining with common signs, symptoms or lab values, the reader is taken through various well annotated steps leading toward the possible diagnosis. Thies is the third edition of this book which has evolved with the times and remains as useful as when it was first published. A must for any medical bookshelf.

Common Medical Diagnoses: An Algorithmic Approach is a great reference book for physicians and medical students alike. The book is roughly 220 pages and has 11 categories of disorders with algorithms under each for either common symptoms or abnormal lab values. The algorithms are very easy to follow, uncluttered, and lead you to a list of differential diagnosis. At each branch of the algorithm reference numbers allow you to read commentary. Only the most common medical diagnoses are in the book, requiring you to search other material for any rare ailment. Also, unless a treatment aids in the differentiating process, the book does not give standard treatments.

This book is a short introduction of how the programming language C++ can be used to solve various problems in computational geometry. It is modest in its goals, and concentrates mostly on typical "bread-and-butter" topics that would be encountered by someone first encountering the field of computational and discrete geometry. Specialized topics in computational geometry and more modern techniques can then be found in the literature for interested readers who need a more comprehensive treatment.

The first three chapters introduce the reader to the notion of algorithms and data structures. The author uses the boundary-intersection problem to illustrate the main points of the chapter, such as algorithmic paradigms and abstract data types. Complexity measures for algorithms are discussed briefly, along with mathematical induction. The linked list data structures he discusses are very important in computational geometry, especially the pointer-based implementation.

In chapter 4, the author discusses the data structures that are needed for dealing with geometric structures in dimension 2 and 3. After a review of vector algebra he defines the point class and then the vertex class. The latter, along with the polygon class, is used to define polygons as a cycle of vertices which are stored in a circular doubly linked list. These are generalized to 3 dimensions where classes are given for points, triangles, and edges. The author then gives an algorithm for finding the intersection of a line and a triangle, which uses projection, and tests for degeneracy before projecting.

The next part of the book deals with applications of the algorithms, such as finding a star-shaped polygon in a finite set of points, finding the convex hull of a set of points, the decision problem for points inside polygons, the Cyrus-Beck and Sutherland-Hodgman algorithms for clipping geometric objects to convex polygons, and an O(nlogn) algorithm for triangulating a monotone polygon. The treatment is very understandable and should prepare the reader for more advanced reading (especially in computer graphics). The famous gift wrapping algorithm for finding the convex hull is given, along with the Graham scan algorithm. Issues more pertinent to computer graphics, such as rendering are discussed also. The hidden surface removal problem is solved via depth sorting. An algorithm is also given for finding the Delaunay triangulation. In addition, the author does a nice job of showing how to use plane-sweep algorithms for computational geometry problems in the plane. An interesting O((r + n)logn) time algorithm for finding the number r of pairs of n line segments in the plane that intersect. Voronoi diagrams are discussed also, which are extensively used in applications. The latter few chapters are more specialized than the rest of the book, and concentrate on divide and conquer algorithms and binary search trees.

This is a clear book on an interesting subject. Computational geometry is a(nother) field where designing object oriented programs is so natural. Examples are clear, explanations also, with a good level of mathematical formalism.
I deplore however that source code is not provided with the book on disk or on the internet. You will have to type the code you want to test.
The paper of the cover is too thin to protect the book.

Don't buy this book. It's a bad computer graphics book, a bad computational geometry book, and a bad C++ programming book.

Several fundamental concepts in computational geometry are screwed up or omitted entirely. For example, there is NO discussion of point-line duality, or of the duality between Delaunay triangulations and Voronoi diagrams, or of the simple connection between 2d Delaunay trianglations and 3d convex hulls. The simple primitive "Are these three points in clockwise order?" is explained using trig (compare angles) instead of linear algebra (compare slopes). [These may seem like technical trivia to novices, but that's why you buy books like this -- in the hopes that at least the technical trivia is done right!]

The book describes slow algorithms for problems such as Voronoi diagrams, when equally simple faster algortihms have been known for many years. Despite its 1996 publication date and the rapid development of the field, the book doesn't reference a single paper newer than 1990, and very few newer than 1980!

Inexcusably for a book with hunderds of lines of source code, the code isn't available online, on either the publisher's or the author's web site. For all we know, it doesn't even compile, much less work!

If you want to learn about computational geometry, this is NOT the book to buy. For programmers, Joe O'Rourke's "Computational Geometry in C" is much more readable, accurate, and up to date. For aspiring computational geometers, Mark de Berg et al's "Comptuational Geometry: Algorithms and Applications" is indispensible. Even the old standard by Preprata and Shamos, depite being 15 years out of date, is better than this one. Laszlo's book is just embarassing.

...The main objective of my book is to explore someideas that arebasic, interesting, and accessible, without attempting comprehensivetreatment. These objectives are stated clearly in the first paragraph of the book's preface. My intended audience are relative novices who need not have prior experience with algorithms, data structures, or linear algebra, and with only limited experience with C++. The book's intended audience is also clearly framed in my book's preface. Indeed, the objectives and target audience are also evident from the table of contents, which shows that the first half of the book is devoted to fundamentals (the design and analysis of algorithms, and basic data structures) that the typical graduate student, much less professional, would have mastered years earlier.

Are my references deficient because the papers it cites are no less than four years old (relative to the book's release date), and some even date to the 1970s? Most of the methods I present were devised years and even decades ago. I chose these methods to suit the book's purpose and audience; I chose methods that are basic, yet which a less sophisticated reader will find interesting and accessible. Similarly, I chose the book's references so they would be relevant to the book's content and useful to the reader.

The choice of what topics to present is always to some degree at the author's discretion, particularly in a book such as this which explores ideas without attempting comprehensive coverage. Critics can always be found who will take issue at the omission of this topic or the inclusion of that, or with how some topic is presented. But again, I chose the material with my book's objectives and audience in mind.

Relative to the expectations of a computational geometer or a graduate student, my book cannot compare to Preparata and Shamos', or to Mark deBerg's. Their audience doesn't require a book that spends half its time covering such fundamentals as algorithm analysis, lists and stacks, search trees, and elementary sorting and searching methods. Their audience would expect only the most limited coverage of these things, or no coverage at all. In contrast, given my book's target audience, to omit these topics would be to leave out the very background that the rest of the book not only requires, but that the intended reader likely lacks. Omitting such material would be a disservice to the intended reader. Likewise, to include certain more difficult topics which are the meat of these more advanced books would go well beyond the scope of my book, and to do this would also be a disservice to the intended reader. My book differs significantly from these other books in its objectives and its intended audience.

Logistics has always been an integral part of industry and the military, and with the advent of the Internet, it has taken on major importance. This book gives a rigorous introduction to the formalism of logistics, and as such is fascinating reading for anyone interested in this area. Even individuals not into supply chain management and logistics engineering, and interested merely in the mathematics, will find this book interesting. After a short overview of logistics in the introduction, the authors discuss worst-case analysis of various algorithms for the bin-packing and traveling salesman problems. They define two performance metrics to measure the worst-case effectiveness: the absolute and asymptotic performance ratios. The First-Fit, Best-Fit, First-Fit Decreasing, and Best-Fit Decreasing heuristics are discussed in detail for the bin-packing problem. The authors show that a polynomial time heuristic cannot have an absolute performance ratio less than 3/2. They also show that finding a heuristic for the traveling salesman problem with a constant worst-case bound is as difficult as solving any NP-complete problem. The minimum spanning tree based, nearest insertion, Christofides', and local search heuristics are all discussed in great detail.

The next chapter considers the probabilistic analysis of algorithms via the characterization of the average performance of a given heuristic. The analysis is asymptotic with large problem sizes needed. Again, the bin-packing and traveling salesman problems are considered for studying this approach. This is followed by an approach to studying the efficacy of a particular heuristic by using mathematical programming in the next chapter. The strategy here is to cast the (NP-complete) problem as an integer problem, and then relax the constraint of integrality and solve the linear program. The authors showthat tight lower bounds can be found for these integer programs. The authors switch gears somewhat in the next two chapters, where vehicle routing problems are studied. In particular, the single-depot capacitated vehicle routing problem with equal and unequal demands is analyzed via worst-case and probabilistic analysis. The analysis is generalized in chapter 7 for the case where time constraints are present. An analytical solution of this problem, called the vehicle routing problem with time windows, is considered in detail by the authors. They back up their analysis with computational results at the end of the chapter. In chapter 8, a column generation approach is employed to solve the vehicle routing problem. No time constraints are put in, and the authors give in detail the steps behind this technique.

The study of inventory models is begun in chapter 9, with the economic lot size model leading off the discussion. This model illustrates effectively the tradeoffs between ordering and storage costs, and the optimal ordering policy is found. This model is generalized to the case where finite time horizons are included and the optimal policing found. Multi-item inventory models are then studied via worst-case analysis. The Wagner-Whitin model, which is an inventory model with varying demands, is formulated and solved in the next chapter. The techniques used, interestingly, involve dynamic programming. This model is generalized to the case where there is an upper bound on the amount that can be ordered or produced, and then the optimal solution found.

The case where the demand is a random variable is considered in the next chapter on stochastic inventory models. Single period and finite horizon models are considered using a dynamic programming algorithm to determine the optimal policy. The analysis makes heavy use of the properties of convex and quasiconvex functions.

Facility location models are the subject of the next chapter. The p-Median, single-source capacitated facility location (CFLP), and distribution system design problems are analyzed as warehouse location problems, with Lagrangian relaxation techniques used to find the solutions to these problems.

Logistics models that integrate inventory and routing strategies are considered in chapter 13, with the success of Wal-Mart given as an example of a firm whose success was generated by a reliance on an efficient logistical design and planning model called cross docking. Along with analyses of zero inventory ordering policies, the authors give an asymptotic analysis of cross-docking strategies.

The last two chapter of the book consider the implementation of logistic algorithms in practice. Although short, the chapters do give a fairly good overview of how these algorithms are used in the real world. The authors consider the routing and scheduling of New York City school buses and a decision support system for network configuration. Only one exercise is found in these chapters though unfortunately.

Professor Simchi-Levi dedicates his time as co-author of this book and I'd like to thank to his effort. The logic of Logistics is only "ONE' book in current academic text books that bravely delineates the theory and algorithm; while most other books spends many hundread pages for "words" and "case studies". The models are showed with algorithm and proving. Examples are included as necessary. The way to illustrate case study is different -but good different. For a researcher, consulting companies, professors, graduate students, you can spend a month in library for literature reviews or take few days to go through this book. If you think your time is worth, grasp this book and you won't be disappointed. If you want to see less mathematic issue, you may want to look at another book of Simchi-Levi. It's "Designing and Managing the Supply Chain : Concepts, Strategies, and Cases".

Very technical with many mathmatical equations, exapmles and theorms. Includes exercises, and case study information. There are however, no answers to the exercises, and few "worked out" math problems. The format is very much a text book.

As above. This is 5+ star theoretical book that shows the dramatic gap between the academia and the industry. I am saying this from my own experience: 20+ years in the academia and now responsible for designing optimization products for large logistic company. As one clever guy said: "academics do what is possible but not needed, practitioners do what is needed but not possible".

I don't know what the guy above is talking about but the math in this book is very elementary. This book is very clear and has plenty of examples. You benifit from this book having only a rudimentary knowledge of C syntax. I highly recomend this book to anyone who wants to get knowledge of data structures in action.

Solutions in the back of the book for odd numbered end of section exercises make it excelent for those who are learning by themselves. Also book does not cheat users, even those who are just starting. Do not be intimidated by its title, this is a beginner's book. After hitting myself against the likes of Deitel and Deitel "C How to Program", which is positively not a begginner's book, I found this jewel.

In "Algorithm Development and Program Design Using C", Bronson uses mathmatical formulas for nearly all the programming examples. Unless you have an extensive math background, the examples in this book are useless. The book is also wordy and long-winded, which makes the explanations of commands difficult to follow. I would not recommend this book for beginners.

I like these little "Teach Yourself" books and found this one useful. It's gives good examples (with problems) of the most commonly used programming algorithms and gave me a good set of basics for further study. Pretty cheap education.

I've taken only one course in programming (C++) and was hoping this book would provide me with a better understanding of algorithms. My biggest problem with this book is that they use their own notation based on older programming languages (such as Pascal) - I had a hard time moving from a C++ way of thinking to figuring out how they were expressing the same thing. It didn't work for me because of this... This book looks as if its over 25 years old and is very British. It has some odd English colloquialisms and is written for an English audience. I really don't think - in an object-oriented world, I could recommend this book - if you tried to move to C++ from this, you'd be very confused.

You know all those game players out there spending their quarters to play video games?

The people who wrote those games started out with books like this one.

Get this book and try writing your own sort algorithms, use the bubble sort, the ripple sort, and then when you've got them down pat, learn the shell sort and the tree sort.

You would think that sorting is boring, but you'd be surprised how useful they become when you want to design a game or puzzle using the computer.

And, when you learn tricks to tweak those skills, you'll be several steps closer to selling a game to Nintendo.

Get this book, and learn some good and useful programming techniques.

John Author of the first "Microcomputer Star Trek game" (released for the TRS-80 in 1978). Before 1978, you could only play Star Trek on teletypes and mainframes.

I recently obtained the second edition of this text, since it seemed like it gave a fresh approach to the topic. I happen to be teaching this topic this semester, and so I went to the chapters dealing with computability and complexity theory. I found several glaring errors in terminology there, and this is simply unacceptable in a text. Apparently, the reviewers didn't do their job here. For example, in chapter 10, the author attempts to treat the classes P, NP, and NP-complete. Unfortunately, the term NP is used in many cases where NP-complete should be used. This leads to several areas of confusion. (Just because a problem is in the class NP, doesn't mean it is intractable -- it could be trivial, since P is a subset of NP.)

In summary, there are several other texts out there that are relatively readable and accurate. Among them are Introduction to Algorithms by Cormen et al, and Introduction to the Design and Analysis of Algorithms by Levitin.

For a long time I have been searching for an algorithm book which is comprehensible, easy to follow. This is the book, I am really looking for. The other books like "Introduction to Algorithms" and most of the others do not give the point of the subject, full of mathematics, strange symbols many unneccessary details, I think that the other authors must follow the approach like in this book.

I wish that the author had also written other books containing the other advanced algorithm issues like network flow, linear programming... I would have bought without hesitating...

I am a professor of computer science and used this book for my Algorithms class. Although it had a few errors, there were many things I liked about it. First, the size of the book is just right; it covers all of the major subjects and I was able to use the entire text in one semester. Other textbooks cover topics in so much detail, I often had to leave many topics out of the course. Second, the active learning approach is great; having students do in class exercises and group projects helped them grasp the material more quickly. Third, I liked the omission of higher level mathematics; our college offers a degree in computer science but also other computer-related degrees which do not require a knowledge of calculus. Any student should be able to grasp the math in this book. In conclusion, I will use this text again and look forward to other authors writing books that "get to the point" quickly like this author did.

What happened to the sections on string processing, geometric algorithms, and advanced topics? The Introduction says parts 5-8 are contained in a separate volume, but the second volume contains only the part on Graphs (which the intro says is supposed to be Part 7) What gives?

If you need a book to introduce yourself in data structures, thats not your book. This books are for consult, not to learn, cos there are leaks : insuficient code, insuficient large explanations and drawings about TDAs. Furthermore, its expensive.
Even trough that, Id recommended part 5 because its a good collection of the most used algorithms based in graphs.

Any professional programmer would benefit from having these books at hand. Excellent discussions of the basic algorithms which every programmer needs to know.

But I would like to particularly highlight the discussions on binary and n-ary search trees. The most enlightening discussion in print, giving the reader a real synoptic view of search tree algorithms, how they evolved, and their culmination in red-black trees.

Other reviewers have mentioned that the algorithms as presented here seem to be just warmed=over versions of their C counterparts presented in the C edition of this work. There is a germ of truth to this, but I really don't consider it to be a valid criticism of the books. The point here is not to present C++ coding techniques, but to understand algorithms. If you want to know what a state-of-the art C++ implementation of Red-Black trees looks like, just read the source code which comes with the GNU compiler toolchain. But you're not going to have a prayer of understanding it until you first understand how Red-black trees work--that's where this book comes in. If you are trying to explain the Red-black tree algorithm, you don't want all of the C++ do-dads and optimizations, templates, etc, all cluttering up the presentation of the skeletal algorithm.

C Algorithms for Real-Time DSP, by Paul Embree, is a stimulating book. When I finished reading it, I went straight to my workstation and started experimenting with DSP algorithms. Embree clearly knows this subject and presents it in a straightforward manner. This is a refreshing change from the academic approach taken by the seven digital-signal processing books currently on my bookshelf. Not that Embree doesn't reference some heavy math. C Algorithms for Real-Time DSP is not for the mathematically weak of heart. To feel comfortable with the book, you should be familiar with time- and frequency-domain math as well as filter terminology&emdash;topics Embree reviews in the first part of the book. Reading this section reminded me of how my entire high-school education was summarized in my first week of college.

This book's title and topics sounds very attractive. Unfortunately, it has nothing more than like a reference card!! The content need more detail presentation and analysis to give readers something valuable. A book with only about 200 pages of headlines sale for more than $70, this is absolutely ridiculous!! The worst book in my colletion.

Within this book, various algorithms can be found. The algorithms are implemented on various DSPs (TI C3x',AD 21xxx and etc) as well. Would be a great reference for students working on their DSP projects.