Book Description
This book is designed to describe fundamental algorithmic techniques for constructing drawings of graphs. Suitable as a book or reference manual, its chapters offer an accurate, accessible reflection of the rapidly expanding field of graph drawing.
Customer Reviews:
Not the best book ever..........2007-09-30
This graph drawing book is, according to my lecturer, one of the few books on this subject. There is a different book too, written by some japanese authors. The drawback of the latter book is that it is too technical sometimes, while this book discusses intuitively understandable algorithms.
But, there are also some major drawbacks concerning this book. Not all chapters are equally good: some are horrible to read while others are very understandable.
Furthermore, the book is not printed anymore, so you just purchase a black-and-white copy of the original book with some fancy cover. Since the book is just copied, some pictures do not look like the way they should and one picture isn't shown at all. This results in some difficulties understanding the pictures and discussed material. I purchased one of the cheaper variants of the book, maybe the more expensive ones are printed versions.
Also, the book is absolutely not free of mistakes!
To conclude: the book is probably OK for understanding the basics of graph drawing, considering what's for sale. But beware of the drawbacks of this book and use it with care.
Who is this book for?.......2003-08-10
I am a mathematician/computer scientist quite interested in the subject matter, but the book is almost useless, since it mostly discusses ad hoc methods, and avoids proving any of the actual theorems in the subject. Unfortunate, since there is certainly room for a good book on the subject.
Not useful for me, maybe for other people.......2003-05-20
To me the book is not useful, because I need to draw graphs in which the distance between two connected vertices is fixed. The book doesn't mention any method to handle graphs with such a restriction, although the chapter on force-directed methods inspired me to use something similar. If you draw graphs without that restriction, the book might be useful to you - that's why I'm careful and give it 4 stars.
I disagree with Viv. R who said it doesn't contain pseudo code, because the book contains quite some of it, though not in every chapter. But even lack of pseudo code doesn't bother me, because for an experienced mathematical programmer that should be no problem.
Good Theory .. but.......2000-12-03
The book has a solid theoretical explanation of most of the popular graph drawing algorithms. So, if you want an explanation of these algorithms from a mathematical point of view, this book is for you.
If you are like me, and want to approach these problems from an 'algorithmic' viewpoint. I.e I want to know how to write planarization, Orthogonal layout algorithms... This book will disappoint you big time...Most of the algorithms are presented in a mathematical form (not a psuedocode form).. It is a huge leap to convert algorithms in this book to code.
Overall, I rate this book a 3 because, it is the ONLY book on this subject. Therefore, I cant compare it with anything else.
My advice is :- math major = BUY, computer major = PASS, after all this book is not cheap -
Very complete, authoritative.......1999-04-01
Well organized, very complete, authoritative. Thanks to the authors for compiling and adding to a most interesting and valuable area of study.
Customer Reviews:
I'm fed up with these books.......2006-03-22
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 an 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.
Best of the bunch.......2004-08-19
I had to teach this subject and this book seemed the best of the bunch though still not ideal. Why does the author have to use meaningless variable names (i,j,k), do comments make the code run more slowly. My main criticism is the examples and I would recommend the author use professional coding practices, comment the code, use meaningful variable names and structure it for readability. Else recommended for this subject
The best book for beginners.......2002-07-26
Sedgewick's 'Algorithms in C' is undeniably the best book for beginners studying about algorithms and data structures. The text is clear, lucid, and the programming examples are very well documented. The exercises and problems stimulate thoughts and help in developing a better understanding of the subject. All the key aspects of the subject are sufficiently addressed, and discussed in the best possible way. It's the code in the book that I love the most, it can be compiled on almost any compiler without almost any change being made to it. I would strongly recommend this book as a textbook to all beginners embarking on a study of data structures and algorithms.
Lucid thought process - excellent coverage & examples.......2002-07-25
I have quite a few books on algorithms and C programming, and this probably takes the cake. Sedgewick writes clearer than perhaps anyone on the subject. The book is filled to the gills with tiny 20 line (complete) programs that do amazing things - such as the program to compute all the prime numbers less than N (provided as input). These examples are typically given to illustrate some point (such as using dynamic array allocation for storing which numbers are prime) - but the short, concise algorithms given in the examples are learning aids as well (i.e. - I didn't know you could calculate a list of primes so easily, and I can probably take this knowledge and use it somewhere else). The reader is challenged to alter the examples (instead of using an array to store which numbers are prime, use a bitmap). Because the examples are small, compact, and easy to read, this provokes one to actually sit down and try and play with them. In contrast, I also have the Algorithms In C O'Reilley book by Kyle Loudon and after reading the Sedgewick title, I'm throwing that away. That book spends 1/3 of the chapter describing the algorithms, and then spends the rest of it in user-interface code examples. Of course, all the user interfaces for all the examples in the book are pretty much the same, so the whole book is filled with redundant useless code. More analysis, less filler, please. As Sedgewick was a student of Knuth, I consider his books as the practical guide to Knuth's tomes (which seem out of date - do we really need algorithm analysis on external storage these days??), which are filled with rigorous mathematical analysis. I highly recommend this book(s) -- actually there are two, with the second volume covering graphs. I wish my University had used these texts in programming / algorithm analysis courses. I really don't have any negative commentary -- other than the nitpick that his coding style is very compact and skeletal --> main(){ for(...) do_something;} However, since the examples are so small, it hardly matters.
Customer Reviews:
More Practical for Programmers Than Cormen's.......2007-09-08
These text(s) do for the software engineer what Cormen's book does for the scientist. To be knowledgable with algorithms will greatly seperate you from a novice.
Very good examples and using Java is very smart because most OO programmers can easily understand the language (C# is practically identical).
For those who struggle with the Cormen book, (Like I did) it would do you well to get this book. You will refer to it time and time again in your career as a software developer while the Cormen book collects dust on the shelf.
A treasure!.......2006-02-25
This series is a treasure to keep. The book is filled with great diagrams and very easy to understand language.
Excellent book.......2005-11-10
First is Knuth, second is Corman that brings the art of algorithms closer to earth. Then is Sedgewick. This book provides very good balance between theory and practice and lets the practitioners know that programming is a bit more than just writing "if" and "for" and that the art of algorithms is not only art but also science. This book evolved from early editions (Algorithms in C, 1990) and keeps the standard. These two volumes is the must for every serious programmer.
Cons: Java code is a bit "C-ish" and makes it clear that it is easy to write C program in Java. In addition, section Geometric Algorithms from 1990 edition and other material following this section is missing in newer editions. Maybe this material will be included in Volume 3, that as rumor says, is in preparation.
Excellent combination of books.......2004-05-26
Sedgewick's publisher (Addison-Wesley) has gathered his two books, Algorithms in Java, parts 1-5, into one resource for developers. Convenient, for you now have something that spans the most common algorithms encountered during computer programming. Logically, the combination of the two volumes is very coherent.
(Below is my review of the Part 1-4 book.)
In my work, I have a bunch of interlinked objects. I can use tables to display these, but showing linkages is awkward. It is far more natural to graph them. This lets me use evolution, for the human eye and brain are excellent at processing images and discerning patterns in them. But I also want to algorithmically find groupings and invariant properties of the graphs. There is a danger here. In graph theory, it is very easy to inadvertantly pose a simple question that is computationally hard to solve (NP-hard). Conversely, I don't want to reinvent the wheel. From graph theory, there may well be properties of my graph that I can easily extract. Certainly, the amount of research on graphs is voluminous.
But how does one take advantage of that? Consulting research journals in maths for papers on graph theory is really feasible only for the career mathematician. But for me, graphs are just a tool; not an ends per se. So I need a book that has the right amount of complexity. It needs to get enough into the subject, beyond the trivial exposition of definitions. Yet it should not bury me in lemmas and theorems.
I found such a book! This one. A well deserved third iteration. The explanations are extremely clear. Before I encountered this text, I used Donald Knuth's "Art of Computer Programming" (which is also put out by Addison-Wesley) and his treatment of graphs. But Sedgewick's discourse is far more extensive and, to me, just as well written.
A bonus is the extensive problem sets at the ends of each chapter. Even if I have no inclination to do them, the results they give are a valuable extension of the text, by providing an extra summary of the research. I only wish that Sedgewick would provide answers, like Knuth. But this is a just a quibble.
This edition has example code in Java. Certainly nothing wrong with that. [I program in Java.] But really the code should be a secondary consideration to you. If you are a programmer and you can understand the text, then you should be of a calibre that you can write the code.
Book Description
Because of its portability and platform-independence, Java is the ideal computer programming language to use when working on graph algorithms and other mathematical programming problems. Collecting some of the most popular graph algorithms and optimization procedures, A Java Library of Graph Algorithms and Optimization provides the source code for a library of Java programs that can be used to solve problems in graph theory and combinatorial optimization. Self-contained and largely independent, each topic starts with a problem description and an outline of the solution procedure, followed by its parameter list specification, source code, and a test example that illustrates the usage of the code. The book begins with a chapter on random graph generation that examines bipartite, regular, connected, Hamilton, and isomorphic graphs as well as spanning, labeled, and unlabeled rooted trees. It then discusses connectivity procedures, followed by a paths and cycles chapter that contains the Chinese postman and traveling salesman problems, Euler and Hamilton cycles, and shortest paths. The author proceeds to describe two test procedures involving planarity and graph isomorphism. Subsequent chapters deal with graph coloring, graph matching, network flow, and packing and covering, including the assignment, bottleneck assignment, quadratic assignment, multiple knapsack, set covering, and set partitioning problems. The final chapters explore linear, integer, and quadratic programming. The appendices provide references that offer further details of the algorithms and include the definitions of many graph theory terms used in the book.
Customer Reviews:
A very handy collection.......2007-04-15
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.
Printout of Java programs.......2007-03-27
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
Useful problem-solving tool.......2007-02-09
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.
A mere compendium of poorly written algorithms.......2007-02-07
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
Customer Reviews:
Missing parts.......2007-08-30
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?
Interesting.......2006-03-17
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.
If you want to _really_ understand red-black trees............2005-06-08
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.
Book Description
Clearly written graduate-level text considers the Soviet ellipsoid algorithm for linear programming; efficient algorithms for network flow, matching, spanning trees, and matroids; the theory of NP-complete problems; approximation algorithms, local search heuristics for NP-complete problems, more. "Mathematicians wishing a self-contained introduction need look no further." — American Mathematical Monthly. 1982 edition.
.
Customer Reviews:
Excellent book!.......2007-06-05
This book is very good. However, it's dense, so you'll have to parse it carefully and never in a hurry.
Well written.......2007-04-06
I bought this book because I wanted to have theory on linear programming including duality, integer linear programming, typical graph algorithms and matroid theory in one book. Up to now I have read only most of the chapter on matroids and I would like to say a big thanks to the author.
Although you will not solve the world's problems with greedy algorithms, my mathematical part of the heart was pleased and satisfied by the theory which explained the very nice relation between matroids and greedy algorithms.
Maybe I will tell you more in a few months
Combinatorial Optimization: Algorithms and Complexity.......2007-02-18
The book's state is very good, so I am satisfied with it.
A classic..........2007-01-11
I won't lie to you: this book is well written but relatively hard to read. The subject is inherently difficult, after all! I highly suggest it, though, because the author is a recognized expert on the field and the price is relatively low. It's worth it even if you enjoy a few pages...
Mmm, algorithms...........2006-11-12
This is a very nice, self-contained introduction to linear programming, algorithm design and analysis, and computational complexity. The contents are as follows:
Chap. 1 Optimization Problems 1.1 Introduction; 1.2 Optimization Problems; 1.3 Neighborhoods; 1.4 Local and Global Optima; 1.5 Convex Sets and Functions; 1.6 Convex Programming Problems
Chap. 2 The Simplex Algorithm 2.1 Forms of the Linear Programming Problem; 2.2 Basic Feasible Solutions; 2.3 The Geometry of Linear Programs; 2.3.1 Linear and Affine Spaces; 2.3.2 Convex Polytopes; 2.3.3 Polytopes and LP; 2.4 Moving from bfs to bfs; 2.5 Organization of a Tableau; 2.6 Choosing a Profitable Column; 2.7 Degeneracy and Bland's Anticycling Algorithm; 2.8 Beginning the Simplex Algorithm; 2.9 Geometric Aspects of Pivoting
Chap. 3 Duality 3.1 The Dual of a Linear Program in General Form; 3.2 Complementary Slackness; 3.3 Farkas' Lemma; 3.4 The Shortest-Path Problem and Its Dual; 3.5 Dual Information in the Tableau; 3.6 The Dual Simplex Algorithm; 3.7 Interpretation of the Dual Simplex Algorithm
Chap. 4 Computational Considerations for the Simplex Algorithm 4.1 The Revised Simplex Algorithm; 4.2 Compuational Implications of the Revised Simplex Algorithm; 4.3 The Max-Flow Problem and Its Solution by the Revised Method; 4.4 Dantzig-Wolfe Decomposition
Chap. 5 The Primal-Dual Algorithm 5.1 Introduction; 5.2 The Primal-Dual Algorithm; 5.3 Comments on the Primal-Dual Algorithm; 5.4 The Primal-Dual Method Applied to the Shortest-Path Problem; 5.5 Comments on Methodology; 5.6 The Primal-Dual Method Applied to Max-Flow
Chap. 6 Primal-Dual Algorithms for Max-Flow and Shortest Path: Ford-Fulkerson and Dijkstra 6.1 The Max-Flow, Min-Cut Theorem; 6.2 The Ford and Fulkerson Labeling Algorithm; 6.3 The Question of Finiteness of the Labeling Algorithm; 6.4 Dijkstra's Algorithm; 6.5 The Floyd-Warshall Algorithm
Chap. 7 Primal-Dual Algorithms for Min-Cost Flow 7.1 The Min-Cost Flow Problem; 7.2 Combinatorializing the Capacities--Algorithm Cycle; 7.3 Combinatorializing the Cost--Algorithm Buildup; 7.4 An Explicit Primal-Dual Algorithm for the Hitchcock Problem--Algorithm Alphabeta; 7.5 A Transformation of Min-Cost Flow to Hitchcock; 7.6 Conclusion
Chap. 8 Algorithms and Complexity 8.1 Computability; 8.2 Time Bounds; 8.3 The Size of an Instance; 8.4 Analysis of Algorithms; 8.5 Polynomial-Time Algorithms; 8.6 Simplex Is Not a Polynomial-Time Algorithm; 8.7 The Ellipsoid Algorithm; 8.7.1 LP, LI, and LSI; 8.7.2 Affine Transformations and Ellipsoids; 8.7.3 The Algorithm; 8.7.4 Arithmetic Precision
Chap. 9 Efficient Algorithms for the Max-Flow Problem 9.1 Graph Search; 9.2 What Is Wrong With the Labeling Algorithm; 9.3 Network Labeling and Digraph Search; 9.4 An O(|V|²) Max-Flow Algorithm; 9.5 The Case of Unit Capacities
Chap. 10 Algorithms For Matching 10.1 The Matching Problem; 10.2 A Bipartite Matching Algorithm; 10.3 Bipartite Matching and Network Flow; 10.4 Nonbipartite Matching: Blossoms; 10.5 Nonbipartite Matching: An Algorithm
Chap. 11 Weighted Matching 11.1 Introduction; 11.2 The Hungarian Method for the Assignment Problem; 11.3 The Nonbipartite Weighted Matching Problem; 11.4 Conclusions
Chap. 12 Spanning Trees and Matroids 12.1 The Minimum Spanning Tree Problem; 12.2 An O(|E|log|V|) Algorithm for the Minimum Spanning Tree Problem; 12.3 The Greedy Algorithm; 12.4 Matroids; 12.5 The Intersection of Two Matroids; 12.6 On Certain Extensions of the Matroid Intersection Problem; 12.6.1 Weighted Matroid Intersection; 12.6.2 Matroid Parity; 12.6.3 The Intersection of Three Matroids
Chap. 13 Interger Linear Programming 13.1 Introduction; 13.2 Total Unimodularity; 13.3 Upper Bounds for Solutions of ILPs
Chap. 14 A Cutting-Plane Algorithm for Integer Linear Programs 14.1 Gomory Cuts; 14.2 Lexicography; 14.3 Finiteness of the Fractional Dual Algorithm; 14.4 Other Cutting-Plane Algorithms
Chap. 15 NP-Complete Problems 15.1 Introduction; 15.2 An Optimization Problem Is Three Problems; 15.3 The Classes P and NP; 15.4 Polynomial-Time Reductions; 15.5 Cook's Theorem; 15.6 Some Other NP-Complete Problems: Clique and the TSP; 15.7 More NP-Complete Problems: Matching, Covering, and Partitioning
Chap. 16 More About NP-Completeness 16.1 The Class co-NP; 16.2 Pseudo-Polynomial Algorithms and "Strong" NP-Complete Problems; 16.3 Special Cases and Generalizations of NP-Complete Problems; 16.3.1 NP-Completeness By Restriction; 16.3.2 Easy Special Cases of NP-Complete Problems; 16.3.3 Hard Special Cases of NP-Complete Problems; 16.4 A Glossary of Related Concepts; 16.4.1 Polynomial-Time Reductions; 16.4.2 NP-Hard problems; 16.4.3 Nondeterministic Turing Machines; 16.4.4 Polynomial-Space Complete Problems; 16.5 Epilogue
Chap. 17 Approximation Algorithms 17.1 Heuristics for Node Cover: An Example; 17.2 Approximation Algorithm for the Traveling Salesman Problem; 17.3 Approximation Schemes; 17.4 Negative Results
Chap. 18 Branch-and-Bound and Dynamic Programming 18.1 Branch-and-Bound for Integer Linear Programming; 18.2 Branch-and-Bound in a General Context; 18.3 Dominance Relations; 18.4 Branch-and-Bound Strategies; 18.5 Application to a Flowshop Scheduling Problem; 18.6 Dynamic Programming
Chap. 19 Local Search 19.1 Introduction; 19.2 Problem 1: The TSP; 19.3 Problem 2: Minimum-Cost Survivable Networks; 19.4 Problem 3: Topology of Offshore Natural Gas Pipeline Systems; 19.5 Problem 4: Uniform Graph Partitioning; 19.6 General Issues in Local Search; 19.7 The Geometry of Local Search; 19.8 An Example of a Large Minimal Exact Neighborhood; 19.9 The Complexity of Exact Local Search for the TSP
All chapters have problem sets and notes and references.
As can be seen, this book has a mighty amount of information, and it is amazingly well-explained. Of course, you need a firm grasp of your linear algebra, and some knowledge of very elementary calc./real analysis and graph theory (although most of the graph theory needed, technically speaking, is supplied in an appendix). You don't even really need to know a programming language, since the authors use a "pidgin algol," explained in yet another appendix, for most of the algorithm stuff; all it takes is an orderly thought process to follow it.
Despite the book's age, it mostly holds up very well in terms of topics and presentation. In the preface to the Dover edition, the authors briefly discuss some more current topics not dealt with in the text and make some (probably also out of date!) referrals for those wishing to "catch up." All in all, this book is a great value both as a text and a reference.
Book Description
Including many algorithms described in simple terms, this book stresses common techniques (such as generating functions and recursive construction) that underlie the great variety of subject matter.
Customer Reviews:
Excellent textbook for researchers.......2007-10-02
The book is an excellent source of combinatorial insights and techniques for researchers, especially those who are not mathematicians. The book is comprehensive but not too dense. Puritans would complain that it skips details, but details can always be found by referring the bibliography. An excellent source of problems, with solutions for earlier versions provided by the author on his web-page. Should turn out to be a classic if not already one.
Sigmas all over the place.......2007-03-31
This isn't your usual "urn-has-3-red-balls-and-5-white-balls" sort of combinatorics book. It's sigma notation all over the place, if you know what I mean.
The first part can be used for undergraduates and the second part is more advanced. The book is broad in scope because, as the author explains, so is the subject matter.
The chapters have "techniques" and "algorithms." It's not a book that has a slew of examples of combinatorial problems (like so many), but leans toward mathematical sophistication in formalizing the techniques. This is either a feature or a bug, depending on what you needs are. For instance, it's not very often that introductory books present derrangements next to Fibonacci numbers. Or explain how calculate the average number of comparisons that Hoare's Quicksort does with a differential equation for the recurrence relation in the context of finite fields. It sounds scary, I know, but if you look at the explanation, you'll see you should have been born a nephew to this author.
In case you like Knuth's Concrete Mathematics you will like this book too (there's some overlap, because both are concerned with the analysis of algorithms). Knuth's book works more on skill-building, and I think Cameron's book is better for theoretical explanation.
Disclaimer: I haven't worked with the whole book (because of a lack of time - "Ars long, vita brevis", as they say).
Excellent book...very clear, well-organized.......2006-06-11
This is a graduate level text that presents advanced material and yet is easier to understand than most high school texts and could probably be used without trouble at the undergraduate level. The writing is vibrant and lucid; it is a pleasure to read. I could come up with a few minor complaints about the presentation of this or that but these comments would be silly and not very relevant.
The book contains an absolute wealth of topics. There is an interesting combinatorial approach to groups, and the book's presentation of certain topics, such as matroids and quasigroups, is among the best I have found; many books make these structures appear painfully abstract and difficult to grasp. The book is organized so that it's fairly easy to skip around, but I actually like the order in which the topics are presented.
This text makes an excellent addition to the collection of anyone interested in combinatorics, and if someone were to buy only one book on the subject, I would recommend this book. I think this would make an excellent textbook--it was used as such in one of my graduate courses, and would probably be suitable for an undergraduate course as well.
Great book for Computer Scientist.......2005-08-06
I am M.Sc.Computer Science student and work for software company. I needed a book covering aspects in Combinatorics and this is the book.
Very helpful.......2004-01-09
Combinatorics is a bit of an oddity. Although a few principles (like pigeonholing) apply in many cases, every combinatorial problem has unique features. Attacking a new situation is almost like starting all over again, unless you can recognize an old problem in your new one.
This book gives a number brief case studies. Its 18 chapters (not counting intro and closing) span a variety of interesting topics. Cameron doesn't write down to the reader - it takes serious thought and some mathematical background to get full value from the reading. The examples are nowhere near as concrete as you'd expect in a popularized version. Still, the author avoids opaque references to specialist terms, and keeps the text approachable.
I have personal reason to like this book more than it's high quality warrants. I was thumbing through it in a store, and skimmed a page that described Kirkman's schoolgirls (a two-level problem in selecting subsets). Quite abruptly, I realized that those charming young ladies exactly represented a problem I had in connecting the parts of a multiprocessor. One or two references later, I had a practical way out of a potentially ugly quandry. This material is not just fun for its own intellectual challenge, it has application to real engineering, too.
Amazon.com
Algorithms in C is a comprehensive repository of algorithms, complete with code. If you're in a pinch and need to code something up fast, this book is the place to look. Starting with basic data structures, Algorithms in C covers an enormous scope of information, with extensive treatment of searching and advanced data structures, sorting, string processing, computational geometry, graph problems, and mathematical algorithms. Although the manual often neglects to provide rigorous analysis, the text surrounding the algorithms provides clear and relevant insight into why the algorithms work.
Customer Reviews:
Plain average!.......2007-05-25
This is an okay book. The algorithms are described in great detail (actually sometimes too much detail), moreover it is not very mathematical. For this reason it could be the choice for the readers fed up of the math in other algorithms books e.g., Cormen et al's.
However the biggest complain I have with this book is that it is overloaded with too much contents. When things could have been described in a few lines, dozens of paragraphes have been used for it. The reader just losts in the text. And interestingly the job is still not done, i.e., the reader is still not able to follow the algorithms easily.
Also for this reason it is not a good choice for someone wants to get a quick overview or revision.
Bought this to complete the series..........2005-07-08
I don't intend to read this book from front to back (well maybe one day if I get really bored) but I think this book does a very good job explaining the algorithm without getting obsessed with overly formal mathematical games. In my opinion the graphs are the most important part of the series, since these are the algorithms and data structures that usually AREN'T included in a programming language's libraries; STL for example. You will find many of these topics in a mathematics and statistics program (how I first encountered them) so the book does get mathematical, but out of necessity.
4 out of 5 stars for sometimes being unclear.
Best of the bunch.......2004-04-20
I had to teach this course and must see it is the pick of the books I have seen on this subject though it is far from ideal. Why can't these people use meaningful variable names and comment the code. Is it the authors intent to teach bad programming practice.
Good content but hard to read.......2004-01-18
I'm a learned industrial engineer in electronics but got into informatics right after my degree. So I never had a course on algorithmic and had to learn nearly everything by myself.
After some years of working in the field, I tought it was maybe time to get some background on the subject so I got this (now an outdated edition) of the book.
Well, it was the book it took the longest to me to finish in the informatics field.
The book explains a whole bunch of basic and more advanced general-purpose algorithms, and so has a good coverrage of the subject.
However, there are two problems with the book:
1) The coding style is very bad: the author likes to use global variables, and variable names are often very cryptic. Example:
* p = parent
* g = grandparent
* gg = greatgrandparent
* c = child
* x = current node
* y = temporary node
...
2) You cannot read this book's chapters in a random way: you have to follow the chapter ordering, because often knowledge of later chapters is based of knowledge of earlier chapters, and, because of the bad coding style you have to often remember the meaning of the cryptic variable names several chapters later when they are reused. If you're like me, you've forgotten the meaning, which means reread that damn chapter, which in turn can again be based on an earlier chapter. You get the picture why it took me so long?
to difficult to understand.......2003-02-14
i feel writer is confused and writes very jumbled together spaghetti code.
to tough to uderstand
horrible reference book
Book Description
From the reviews of the first edition:
".... The book is a first class textbook and seems to be indispensable for everybody who has to teach combinatorial optimization. It is very helpful for students, teachers, and researchers in this area. The author finds a striking synthesis of nice and interesting mathematical results and practical applications. ... the author pays much attention to the inclusion of well-chosen exercises. The reader does not remain helpless; solutions or at least hints are given in the appendix. Except for some small basic mathematical and algorithmic knowledge the book is self-contained. ..."
Mathematical Reviews 2002
This thoroughly revised new edition offers a new chapter on the network simplex algorithm and a section on the five color theorem. Moreover, numerous smaller changes and corrections have been made and several recent developments have been discussed and referenced.
Customer Reviews:
Not a gifted writer.......2007-02-13
[...]I have at least half of both volumes, and it really seems to me that there are real problems here with the exposition. Let me see if I can elaborate.
Here is an actual sentence from the book-
We construct a symbol table that is made up of an ordered array of keys, except that we keep in that array not the key, but an index into the text string that points to the first character of the key.
Consider that there are two possible conflicting meanings of the sentence fragment :
...an index into the text string that points to the first character of the key.
In the first meaning, there is an index that points to the first character of a string which string has the property that it, in its turn "points to the first character of the key". (a String is engaged in pointing and so in the index.)
In the second meaning, there is an index that points (into) a text string and in fact that index points into the FIRST CHARACTER of that text string, and that first character the index is pointing to, well, that is the also first character of the key. (only the index is pointing; the string pointeth not.)
OK so how do you describe what's missing here? At least the disambiguating use of commas, at least. It's as though he likes to write in subordinate clauses, but thinks it's economical to leave out the punctuation (which, it is true, there are no hard and fast rules for).
So it's just sentence after sentence after sentence like that. Sometimes you can understand what he's saying. Other times, really you just can't. IF each sentence has 2 (or more!) possible interpretations, and each sentence depends on your understanding the last (as is the case- he never says the same thing in two different ways), then you get this ambiguity growing at the alarming rate of x^2, an observation the author might enjoy.
As the other reviewers said, the code is a C programmers attempt to write in Java. This never goes well.....
But the fact remains it is still the most accessible and thorough coverage of some of its subjects. So what are you going to do?
I don't get the impression he is deliberately bartering in obscuratism, it's just that this book suffers (and so will you) from a lack of editing, a lack of reviewing and feedback by genuine, unaided learners etc. etc.
You might want to check other people's lists for alternatives. Or not. Perhaps that passage was perfectly clear to you.
Excellent, with 1 caveat.......2006-09-04
I give this book 5 stars for everything but the Java code, and 2 stars for the Java -- 4 as a weighted average.
Regarding the code, the authors flout standard Java conventions, which makes reading the Java code tedious for anybody with a lot of Java experience.
Things like uppercase fields and parameter names are only minor annoyances, to be sure, but so is ReAdInG TeXt LiKe ThIs AlSo JuSt A mInOr AnNoYaNcE, and there is no reason to not write code using the conventions of the language you're writing in rather than the conventions of the language your book was first written in or your own arbitrary conventions.
Having said that, I have no other gripes, and the book has much else to commend it.
The prose is very clear and exact. Whenever I found some description or definition confusing, a careful re-reading and consideration of every word included always cleared up my misunderstanding. This is not one of those books with sloppy definitions that confuse you if you really try to understand why every word in a definition is included.
The typesetting and typography is very well done: the pages are easy to read, with good contrast, and there are large margins for writing notes, summaries, and the like. There are many very helpful diagrams that illustrate pictorially the data structures and algorithms under discussion. Lastly, the exercises are at just about the right level for the intended audience.
In summary, if the CJava code were replaced with pseudo-code or idiomatic Java, I would give this my highest recommendation, and even with the many C-isms, I still very much enjoyed and benefitted from reading it.
Short on Practical Examples?.......2006-02-25
Another reviewer gave this book a one star rating citing that the book falls short on practical examples.
In light of that, I'm concerned that other readers might overlook what, in my opinion, may be one of the most comprehensive and well written introductions to graph theory and graph algorithms that there is, and certainly one of the best that I have personally come across thus far.
Recently I took on a project wherein I needed to solve a shortest path problem for a particular kind of graph. I am not a specialist in graph theory and needed practical information that I could utilize immediately. For me, this book fit the bill and was a godsend.
It is true that I already had a practical real world application in mind before I even knew of this book but this book has exceeded both my needs and expectations.
It is easy for me to understand how you may not initially see the practical value of the information being presented, if the sole reason you're studying this book is simply because it is a part of your college curriculum. I think, however, that that does not lessen the value of the book, especially for those of us who do have practical applications for the material.
If you are looking for an informational resource for a real-world problem related to graph theory, you would do well to consider this book.
The book does actually open by citing several practical examples of areas where these algorithms can be applied, although, perhaps the reader who assigned the one star rating may have appreciated and benefited from a case study.
`Algorithms in Java' aka `How little code does it take to confuse people?'.......2006-02-10
I have the dubious distinction of having taken a class that used this book as it's central text. The illustrations are great. The explanations of algorithms and general algorithm design concepts are clear. The code, however, is neigh unreadable in a lot of places.
This was a huge problem for me, as I had a lot of difficulty seeing a clear mapping from the concepts explained to the code examples. Sedgwick's code examples often build on previous ones to the degree that they are not understandable on their own (this is especially true with the graph algorithms in part 5). If you try to use this book as a reference you will find yourself digging much harder than you would like in order to understand code samples that are actually quite simple. You could see how this might make a programming based course difficult.
Thorough, well written and illustrated, excellent.......2004-12-29
This is an excellent book. Robert does a great job leading you through the fundamentals of algorithms and algorithm analysis. The visualizations are very well done. In particular the sort algorithm coverage is very well illustrated and described.
The best parts of the book are sorting and searching. A wide variety of algorithms are explained and demonstrated in detail. The code is solid and the writing is very good.
This is the set of Java algorithms books.
Books:
- Harry Potter Paperback Box Set (Books 1-6)
- History: Fiction or Science? (Chronology, No. 1)
- History: Fiction or Science? (Chronology, No. 1)
- History: Fiction or Science? (Chronology, No. 1)
- History: Fiction or Science? (Chronology, No. 1)
- History: Fiction or Science? (Chronology, No. 1)
- I Am a Strange Loop
- Information Literacy: Essential Skills for the Information Age Second Edition
- Intimate Relationships: Issues, Theories, and Research
- Introduction to Automata Theory, Languages, and Computation (2nd Edition)
Books Index
Books Home
Recommended Books
- Inside Intuit: How the Makers of Quicken Beat Microsoft and Revolutionized an Entire Industry
- Experience Yoga Nidra: Guided deep relaxation
- Archaeologies of Vision: Foucault and Nietzsche on Seeing and Saying
- Bringing Out the Winner in Your Child: The Building Blocks of Successful Parenting
- Earthcore
- Carpentry
- Birding by Ear: Eastern and Central North America
- Sara and Eleanor: The Story of Sara Delano Roosevelt and Her Daughter-in-Law, Eleanor Roosevelt
- AUTOBIOGRAPHY OF A BAREFOOT BUSINESSMAN: THE STORY OF A REAL GODFATHER
- Over There: A Marine in the Great War
Web Graphics
| Web Design
| Web Development
| Computers & Internet
| Subjects
| Books
Drawing Graphs: Methods and Models (Lecture Notes Series)
Graph Drawing Software (Mathematics and Visualization)
Holub on Patterns: Learning Design Patterns by Looking at Code
Introduction to Graph Theory (Dover Books on Advanced Mathematics)
Computational Geometry: Algorithms and Applications, Second Edition
