Customer Reviews

Data Structures and Problem Solving Using Java

5 star:		(8)
4 star:		(4)
3 star:		(4)
2 star:		(5)
1 star:		(10)

 

 

I am using this book in a class on Data Structures and Algorithms. This book has a lot of material and code in it which makes it good. However, his explanations are terrible. They are ambiguous and unclear. If you can teach yourself from the code, then this is a good book for you. If your looking for clear explanations, look somewhere else.

[A review of the THIRD EDITION 2005]

The book teaches two things. Algorithms that are very useful in computing. And how these can be coded in Java.

The explanation of the algorithms requires a reasonable amount of mathematical sophistication on your part. They all relate to discrete maths, and cover topics like sorting, random number generation and graphs. The complexity of the discussion is less than that in Knuth's "Art of Computer Programming". Perhaps more akin to Sedgewick or Aho's algorithms texts. There is a fair amount of abstraction that you'll have to deal with.

The other task in the book is explaining how Java is well suited in which to code these algorithms. Weiss also makes good use of the Java interface ability. If you think of an algorithm as being implemented in a subroutine [ie. a procedural approach], then the book uses interfaces to let you design a program at a higher level, and making it quite modular and independent of specific implementations of given algorithms.

The book does deal with Java 5. But perhaps the most important aspect of Java used in the book is the interface. So the book is quite germane even if you are using an earlier Java.

But what if you program in another language? Is the book relevant? Quite possibly. Firstly, some other languages, like C#, have interfaces. More importantly, if you regard the algorithms as the most important aspect of the book, and you are a skilled programmer, then coding is the easier aspect.

A remark to a lecturer: If you are teaching a course and are contemplating this book as its text, be careful. Try to ensure that the expected background of your class is compatible with the book. For example, if they will be experienced Java programmers, but have little maths knowledge (and this combination is certainly possible), then the book may not be very useful to them.

I got the 2002 edition of this book for a class one and a half year ago. It is a great book. Yes, the book covers some of the basics of Java, then it goes into various analysis, algorithms, implementations, etc. It is not for beginners, and some math background will help tremendously. There is no way we could have covered all the topics in the book. It is simply too rich. It is very well written and contains great explanation. I especially like the Big Oh introduction. I found myself getting even more out of it every time I go back and read it again. Just like everything else in life, repitition is the key.

This book provides an introduction to algorithm analysis, and data structures and is aimed at an audience with little previous programming experience.

The first four chapters are devoted to preliminaries including a brief overview and explanation of core Java, references, objects,classes, and inheritance.

The second part of the book covers fundamentals of algorithm analysis, data structures, recursion,sorting algorithms, and randomization. Weiss's presentation of these topics includes some theorems and proofs, but is not mathematically rigorous. The example programs are generally clear and concise. The exercises and projects at the end of each chapter are straightforward.

The third part of the book is devoted to applications of the data structures and includes word search puzzles, tic-tac-toe, a balanced symbol checker, file compression, a cross-reference generator, and graphs.

The fourth section is devoted to implementations of data structures. Here is where Weiss's work falls short. Most of the implementions presented are adequate, however, the binary tree traversal code that Weiss supplies in Chapter 17 is not only unimpressive but also exasperating. What should be an elegant, concise algorithm is transformed into an incomprehensible mess. Even a mediocre undergraduate should be ashamed of coming up with something this twisted. More elegant treatments of this subject are provided in Sahni's books.

The appendices,covering Java platforms, operators, library routines, and graphical user interfaces, seemed unnecessary.

In short, the book is adequate only at the introductory level. Serious students and those who require a more detailed and rigorous approach should look elsewhere.

Extremely esoteric. Weiss is a terrible explaner of complicated ideas. Virtually every student in the Java class at my university complained about his terrible writing. DO NOT BUY THIS BOOK.

This book is a poorly assembled JAVA translation of Weiss' other books on data structures, and isn't worth the paper it's printed on. At first it appears as though there are many different examples, but if you try to implement some of the more complicated data structures, you'll quickly find that the concepts aren't well presented, and the explanations are often cryptic and/or incomplete. Don't turn to the code examples in this book to figure out what he's trying to say, because many times they are simply incorrect. In order to find the working code, you'll have to download it from his website. Weiss understands the material really well, but simply can't explain it. We've all known this type of person, and they make terrible teachers. Save your money.

I was required to purchase this text for my course. Having never programmed in java before and not having a strong programming background, I found this book almost impossible to follow. This book is definitely not for beginners and assumes previous knowledge of java. I did not find the explanations or examples in the book clearly written. After continued complaints from the class, the professor abandoned the book altogether after just 3 weeks. If your a beginner, stay away from this book.

This book is a college textbook for my data structures java class. I was not new to programing at the start of my course, however I was new to OOP. This book does a horrible job of explaining the concept of OOP which, in my opinion, is difficult to grasp at first. The information in this book is very dense. Complex concepts are only given an explanation that is a page or two long (ex: Binary search trees). The examples aren't horrible, but they lack ample documentation. Now that I fully understand the concepts (thanks to the internet) this book makes an alright reference. Overall, if you already know Java or C++ or a similar OO language, this book is probably exactly what you need to learn how to store your data in Java, but if you don't know what OOP is, look elsewhere.

I just finished a data structures course where we used this book. The book is decent, but I know if I had not had earlier experience with C++, I would have been lost.

I think the intention with this book was to present the basic ADTs (abstract data types) in a sufficiently generic way that you could "transport" the ideas to other languages. However, as other people have mentioned, the example code provided in the book is not very detailed. Despite the sparse code, I was still able to write my own data structures in JAVA and feel that the book prepared me to write them in other languages as well.