Rating: 
Summary: Implementation problems
Review: (I would have liked to give this book 3 1/2 stars.)Some of this book is quite good, especially some of the diagrams and the discussion of graphs. And I found the coverage very thourough in breath and depth. That is, there are a lot of things covered that would be normally ignored in an undergraduate book, and I never felt myself wondering about the "why" of some particular aspect of an algotrithm. I also liked how the authors always gave original credit and references for the pioneers in our field. There is also a nice coverage of Big-O notation, etc.. But... I thought the book was poorly organized, and in some cases the explanations were a little scattered and/or confusing. My biggest pet peeve is that the authors do not seem to have a firm grasp of all Java idioms, and how Java is used in the real world, or even perhaps of good object design principles. Of course, this is a pretty typical problem of academic texts. Just to give you a flavor of what I'm talking about, on page 212, the authors implement a Lexiographic class that has a lot of Java boo-boos. First, they have a method: private void getXY(Object a, Object b) { ... } that actually sets the internal state of the class from the values supplied by a and b. Horrors! Hopefully, most working Java programmers would know that the pattern Object get*(); is a _very_ specific Java idiom for a class property accessor. The authors continue with a number of methods of the form boolean isLessThan(Object a, Object b) which compares two values and returns the results of that comparison. Again, the pattern boolean is*() is a very specific Java propert accessor idiom, and should not be used willy-nilly. If it is used with paramaters, it should be used in the sense of the paramaters provide a context for returning some inforamtion about the state of the object. i.e. boolean isLessThan(Object a) { //Pseudo code!! return this < a; } called with b.isLessThan(a) This is pretty egregious example, and most of the book is quite a bit better at following Java idioms. But in general I thought most of the implementations were pretty awkward when compared to the Java collections library, for example. Still, this book will end up being used by a lot of undergraduates and people just getting familiar with using Java correctly. If they don't learn how to do things the right [;-)!!] way in their texts, where will they learn it? And if they don't we'll all suffer, because we'll end up having to decipher their code. Anyway, aside from these admittidly anal complaints, I think this book would serve as a good "one of many" texts. Everyone should have Knuth probably, and then maybe one other data strucutres book, and then spend some quality time pondering well implemented (Java collections!) libraries.
Rating: 
Summary: More faults than the Pacific Rim
Review: After being forced into purchasing this textbook for a course at my school I made a major mistake. I actually memorized the psudeo code for many of the algorithms, so I could use the code on my exams. Unfortunetely after my exams, I found out that most of the code I had learned from this book was completely wrong! In some cases the code doesn't even work. In others the code does the actual exact opposite from what the comments describe. This book has an errata sheet 12 pages long, and it should not be ignored. This text cost me several critical marks on a couple of exams, and that is simply inexcuseable. Just because most software is full of bugs, doesn't mean that the books on how to write code should be too.
Rating:
Summary: Easy to understand; easy to use; good basic refernce
Review: Goodrich and Tamassia's book offers a very good introduction to data structures. Their explanations are easy to understand and read (e.g., good typesetting) with java implementations accompanying most. The authors challenge the reader with their implementation examples by giving incomplete solutions that can or, if instructor choose, must be completed. Additionally, the end-of-chapter problems are thought-provoking requiring creative solutions. Goodrich and Tamassia's addition of a Java primer - an appendix dedicated to Java's basics for transitioning, not new, programmers - and Microsoft J++ only enhance the purchase. On the down side, the book has many typos which detract from the well-written text.
Rating:
Summary: Terrible book! Poorly written and organized.
Review: I am currently enrolled in a "Data Structures and Alogorithms in Java" course and this is the book we are using. This book is NOT a good book in any way, shape, or form. The book provides very little code to follow up explanations, lacks organization and flow, and is difficult and confusing to read. Some of the more important topics such as exceptions, staques, and queues are just a few pages long and do not thouroughly explain the purpose of such ADT's. A significant part of the book deals with complex mathematical algorithms that are of no concern to someone just starting out in data structures. I would highly recommend looking into another book dealing with the topic of data structures, such as those by Weiss, Waite, or Main. Even the teacher for my class would not use this book again!
Rating:
Summary: Terrible book! Poorly written and organized.
Review: I am currently enrolled in a "Data Structures and Alogorithms in Java" course and this is the book we are using. This book is NOT a good book in any way, shape, or form. The book provides very little code to follow up explanations, lacks organization and flow, and is difficult and confusing to read. Some of the more important topics such as exceptions, staques, and queues are just a few pages long and do not thouroughly explain the purpose of such ADT's. A significant part of the book deals with complex mathematical algorithms that are of no concern to someone just starting out in data structures. I would highly recommend looking into another book dealing with the topic of data structures, such as those by Weiss, Waite, or Main. Even the teacher for my class would not use this book again!
Rating: 
Summary: Data Structures and Algorithms in Java
Review: I am currently using this book in a course at Purdue Univ. This is a terrible book. If anything, one should only use this book as a reference to look at the code -except there are soo many errors in the code ... so maybe one _shouldn't_ even view that. This is clearly not a book to study from. If someone finds a better book please post the name of it in here.
Rating:
Summary: epitome of a waste of paper
Review: I am taking a beginning course in algorithms this semester at Purdue and I have to conclude that nobody is learning anything from this book. Everybody I talk to here thinks the book is terrible (contradicting what a previous reader from purdue thought). The code is very useless and could be implemented in much better ways. They don't even explain what they are doing in their code! I also found the explaination of induction and big O notation to be patheticly short since that is a big part of the course. A book like this should focus more heavily on this and analyzing different loops to make a determination of their running times in functions. The main point of any book in cs is to provide real programming projects and take the reader through the development of them. This book glosses over very important topics like the ones I mentioned and seems to make it a goal of trying to confuse the reader. In short, there are much better books on this subject.
Rating:
Summary: Nice book if you like mathematics
Review: I am using this book for a course on the Dutch Open University. As I am aleady graduated on Operations Research, it is really nice to see how some algorithms like the shortest path and the maximal flow can be implemented with classes in Java. This first part of the book is more concerned with the basics and can be a bit boring before the real fun begins. However, the abstract level is quit high and sometimes it takes some effort to fully understand what the author means to say. If you like mathematics tou probably will like the book.
Rating:
Summary: I don't know where to start . . .
Review: I bought this book as a required text for a class. Hmm, I wonder if this book would have sold so many copies if it weren't required for a class. In any case, I repeatedly attempt to use this book, hoping to glean some morsel of information to help with my course work. If my professor doesn't assign homework from the book, I guess I would have read less than 1/10th of the book. The whole section on Asymptotic Notation and Asymptotic Analysis left me with one question -- Huh??? It was a push/shove off the deep end. I often find myself having to refer to other text or to the internet for clarification of certain concepts in the book (I've bought four additional books since starting the class). Some of the Pseudocode presented were useful while others are very cursory and don't even start to scratch the surface. I am not one to memorize anything in a text, believing in understanding concepts and finding the information I need information quickly in a book. This book had so much word in it that the important information are usually buried several paragraphs into the section. The index does not adequately cover the book as well.
Rating:
Summary: Lafore's Data Structures & Algorithms is more understandable
Review: I bought this required text not by choice and doesn't like it at all. The explanations are confusing. Worst, there is no solutions to its exercises. I highly recommend Lafore's Data Structures & Algorithms in Java, either as an substitute or additional reference.
| 
