java

The book is not bad, but not that good either and the $56.90 I paid Amazon for it is too a high price.

Good things about the book-
It has a compact size and it has these 2.5 inch margins for people to write stuff in; comments for the code are in a special color; nice pictures; neat information - such as a table of frequencies of alphabet letters (the section about Huffman encryption); also, a nice bibliography at the end of every chapter - so we can buy more stuff from this guy...; finally, most of the information is quite useful or important - it's not a book with a lot of junk in it.

Now the bad things about the book -
It simply doesn't cover enough stuff and it should be priced at about $20 rather than $53; Besides 2.5 inch margins, the Appendix stretches from page 423 - 545, so there's not that much material; To make everything worse, I think the author talked way too much about Java language specifics - instead of being the 100% data structure book with examples in Java code, the book is like a 75% data structure book and 25% Java language review session. The reviews might be helpful for other people, but I just skipped over 25% of the book. More importantly, the code in the book is way too cryptic cause the guy kept using these 1 letter variable names (p for pivot, R for right, L for left, i, j, k, sometimes do NOT stand for counters in for-loops)

to sum it all up, the book is not bad, but it has bad variable names and it just doesn't cover enough material to make me happy about spending my $56.90. Now I have to buy that Weiss guy's book to get a handle on some of the more advanced stuff

This book is a well-written and concise treatment of abstract data structures. I used it to prepare for graduate level study that requires prior knowledge of abstract data structures, algorithms, and Java. The chapters are very well laid-out, the explanations are clear, and the code snippets are serviceable.

I had two main problems with the book. First, the chapter on graphs and trees was far too advanced for a CS2 student. Second, the author left key programming concepts as problems for assignments, rather than introducing the material in the body of the book. An example is rotating a binary tree in order to balance it: the general idea is introduced, but techniques were left to the student to devise; OK, I figured out at least one way, but it would be nice to know about others without chasing down another textbook.

A final positive note: the appendix introducing the Java language is complete enough that I used it as my primary reference in learning the syntax of the language.

As a student who completed a data structures course using this book, I believe that I can offer a review that has special insight that might be lacking in a typical review.

Overall, the book is very solid, and it accomplishes its purpose. Standish takes a naturally abstract topic and provides numerous visuals and models to help the student visualize ADT's. Without these models, a data structures book would not only be extremely dry, but also difficult to follow. This is certainly the book's strong point. There is no doubt in my mind that Standish is a great teacher of data structures because of this. Also noteworthy is the setup of the book. Recursion, a difficult but essential topic in computer science, is covered early on. For the CS2 programmer, recursion can be very difficult at times, and it is critical that the reader understands the value of incorporating this technique into ADT programs. In addition, chapter 5 covers modularity and information hiding, which partially introduces the essence behind ADT's. I think this is a great placement of this chapter, because when we get into real ADT's, like Stacks and Queues, we understand the purpose of ADT's: all we need to know now is the operations that Stacks and Queues have to offer. In short, this placement of the chapters allows for quick and easy understanding of a subject that is not concrete by definition. Another good point is its sorting chapter, which covers almost any sorting and searching algorithm you could think of, including Radix Sort and ProxMap sort, which are difficult, if not impossible, to find in other data structures books.

The only negative point about the book is the price. For its price, the books should be 50-100 pages longer. And by that, I don't mean extending long appendices, which contribute to the mediocre thickness of the book already. When I finished the book, I thought I got most of what data structures in computer science had to offer. But I was dead wrong. I found another book (I don't recall the author) that covered trees which I never heard of, and other advanced ADT's like binomial queues. Sorry, you won't find anything like this in this book. In addition, there just aren't enough exercises offered in this book that present any real challenge. That may be up to the ability level of the programmer, but in most exercises, all that is required to complete them is just a simple modification of a source code example. That, in my judgment, is not enough if one wants to build up any skills in programming.

In conclusion, the book may have its shortcomings, particularly in its length, but overall, its fabulous explanations of an obscure topic more than make up for any faults. This book is excellent for an intro to data structures ONLY!