Customer Reviews

Data Structures and Algorithms in Java

5 star:		(7)
4 star:		(9)
3 star:		(5)
2 star:		(10)
1 star:		(14)

 

 

I'm finding the 4th edition reasonably clear and comprehensive. However, the book is teeming with typographical errors. Most of them are typesetting errors involving superscripts and subscripts that overlap the adjacent characters so they aren't fully legible. But there are numerous other miscellaneous typos.

So, I've been marking them in my copy, in order to submit them to the authors or publisher, but apparently they don't want to know about the typos. The "errata" section at java.datastructures.net contains no errata and no instructions on how to submit errata. I wrote to one of the authors to ask how to submit errata, but received no reply.

When I learned that this was the required book for my introductory data structures class this semester, I was somewhat worried by the large number of very negative reviews I saw it had received here. However, during the first class meeting, the professor made a point of instructing us to get the third edition (published in 2004), explaining that the differences between the second and third editions were significant.

Judging by the older reviews below, he was right - the book I read seems to bear little if any resemblance to the one denounced by the other reviewers. I found it clear and readable, though it was rather basic and dry. But then, I wasn't expecting great literature - this is a introductory compsci textbook, after all. Though it could be dull at times, it generally managed to get its information across clearly, which is all it needs to do. There were some typos, of course, though probably not more than should be expected to accompany such a major revision. The book's main flaw was an index that had essentially no relation to the actual text itself. A corrected index is available at the book's Web site.

In terms of organization, Goodrich and Tamassia start off with a brief introduction to Java, object oriented design and a brief and very basic discussion of running time and asymptotic analysis. They then work their way through basic data structures and abstract data types - stacks, queues, vectors, lists, trees (general, binary, and binary search), priority queues, heaps, dictionaries, hash tables and graphs. They discuss the structures' purposes and major operations, analyze the operations' running times, and include decent, heavily-documented Java implementations of some of the structures and methods. They also do some stuff with algorithms, though generally nothing very complex or sophisticated. I used this book in an introductory data structures course at a liberal arts college, which managed to cover pretty much everything in the book with little difficulty.

There are a lot of exercises at the end of each chapter. Goodrich and Tamassia divide them up into progressively more complex "Reinforcement", "Creativity" and "Projects" sections. My instructor preferred to assign problems and programming assignments of his own creation, though, so I don't know how helpful or useful the exercises in the book actually are.

All in all, it seem Goodrich and Tamassia noticed the sort of reviews the earlier editions of this book were getting and took steps to correct the many problems they had. I expect that if you have to use the book in a data structures course, you'll find it at least reasonably clear and generally acceptable. As long as you're using the third edition, that is.

Like many other reviewers, I had to purchase this book for one of my CS courses. As a reference book, it gets no more than 1 star. I find it often confusing in its explanations, incomplete code examples and uneven pace. I understand that it was designed to be a textbook, but it miserably fails to be of any value to a student. For 100+ bucks, I expected a lot more.

This is required reading in a CS course I take, and I find it to be an annoyingly confusing book. The language is exceptionally unclear, remeniscient of a bad math book on calculus. The code examples of ideas are sparse and skinny on details. Far too often something is "trivial" or left as an exercise. In addition the accompanying exercises are far harder than the in text material (what little there is to look for for reference). Some subjects which I would expect to have several pages on, IE: the ideas of polymorphism, casting and inheritanc , contain a mere page or less. The claim that the book is "well illustrated" is also quite false, unless you feel like counting the pictures in the headers of the chapters. Overall I have found this book to be a meanace to my learning the material and I am thankfull that I possess an exceptional CS teacher who is able to fully explain what the book fails to do. {Hint to the authors: your book should NOT read like a lecture, it should read like a real textbook, one that actually covers MORE than the professor does in class instead of far less.)

As a side note, I wish to note that Professor Morelli's book Java, Java ,Java (ISBN 0130333700) is most excelent (although it does not cover the same topic) some of the intro materials (chapters 1 and 2) overlap, and I found myself referring to it constantly in preference to this monstrosity that I now call a textbook.

I was required to purchase this book for a second-semester data structures class. It is totally useless to me. There are very few Java examples, and the few examples they do have are very poor examples. The author's website is just as useless as the book. I tried to access the student hint server quite a few times and always came away with nothing. I always get a message saying "Sorry, no hint available for this exercise". If you want a good book covering data structures check out Data Structures and Algorithms in Java by Mitchell Waite ISBN 1-57169-095-6. We used this book in my first-semester Data Structures course. It covers everything in detail and also gives detailed source code. It costs less than Goodrich & Tamassia's Data Structures book, is twice the size of their book, it covers everything that their book covers, and comes with a cd containing sample applets that demonstrate the concepts you are learning as well as the source code for all programs in the book.

While this may be a good book for expanding knowledge of Java for an experienced Java programmer, this book is not particularly successful as an undergraduate text. It is especially poor as a (ACM/IEEE) CO1 text. The book inadequately explains Java features not covered in popular introductory Java based CS1 and CS2 introductory programming texts. Further, the book's explanation of data structures and algorithms are at best muddled. The book's exposition on implimentation issues is almost non-existent. The reader is left to intuit why linked structures are being implimented the way that they are. The chapter on priority queues is especially bad in this regard. No clear explanation is proved for why heaps have peripheral null elements. Further, the text does not adequately support students coming into the course with deficiences in MA1 (discrete mathematics) and especially in asymptotic analysis. Fortunately, there are alternative books coming onto the market. I sincerely wish that one that I received a few weeks ago was around when I adoptiing a text for my Design and Analysis of Algorithms course.

I have taken Java programming, and feel that I have a strong understanding of the language.However, I'm currently using this book in my CS class and find this book useless for learning Data Structures and Algorithms(ADT). I have recently purchased another book to use as a cross reference to fill in the many holes this book has.

While this subject tends to be abstract to begin with, this author takes abstaction to a painful level. This book is not for learning Data Structures and Algorithms, but maybe(I emphasize maybe)useful as a reference book if you know the subject already.

With the poor examples and explainations, most of the problems in the book are impossible to do with out some cross reference.

Some how I think the author lost sight of who his readers are and the purpose of this book, which should be to explain the subject in detail and at the level of his intended reader.

I found it amusing that a Rutgers student actually liked the book. It was used for 1 semester at Rutgers and none of the Professors nor any of the TAs liked the book; in fact, there was a near unanimous hatred of the book.

The authors base all of their data structures on a sequence abstraction that is of their own invention; a "data structure" that no one has ever seen before. This abstraction is not needed and is worse than useless but you can't skip it because *every* chapter and topic ultimately depends on it. This dependency messes up all the other data structures and algorithms. For example, instead of the usual insertion and deletion routines from a binary tree, the authors have to use some weird "expandExternal" and "removeAboveExternal." (The authors even mess up the definition of a binary tree!) QuickSort is another example. Instead of sorting on a single array, the authors have to allocate new sequences for each sublist where each subsequence has an unspecified underlying implementation; it may even be implemented using linked lists! -- that would be about as horrible an implementation of quicksort as you could get; the authors follow the philosophy of giving two different implementations for every data structure whether it makes sense to do so or not.

With the exception of stacks, queues, and linked lists, the presentation of *every* data structure and algorithm has some major fundamental flaw.

Their Java implementations are just as bad as the rest of the book. They have lots of errors including some rather basic mistakes. It looks like the code writing was given to a first year graduate student who could not have tried to run the code to see if it actually worked.

Burning books is about the worst thing you can do to a free society but burning this book would be no loss.

This book, as many have said, is used in numerous introductory courses in computer science. It was recently dropped by my college after it was disowned by the professors who chose it -- we students threw so much scorn on the book no one wanted to admit they had anything to do with it.

The book has a very idiosyncratic style. It likes to use some unnecessarily specific class and method names for its examples (e.g. The authors create a binary node class -- BTNode -- for you and then never use it, but go back to their BTPosition class) and fails nearly every time when it attempts to justify certain proofs about big-O and algorithm runtimes. In fact, the authors seem to think it adequate to make a broad statement and then give a simple example.

All in all, you're best finding webpages written by random professors than purchasing this morass.

(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.