Customer Reviews

Data Structures & Algorithms in Java with CDROM (Mitchell Waite Signature)

5 star:		(22)
4 star:		(6)
3 star:		(0)
2 star:		(2)
1 star:		(1)

 

 

I am surprised that most instructors haven't banned this book! It is absolutely one of the best data structures references on the market and with answers provided with the enclosed CD, one perfect "cheat book." Virtually all the standard data structures for an introductory DS&A course are included here with a good explanation behind the rationale used in the implementation of the code. Lafore is a good writer and explains things well, unlike certain authors. The book isn't heavy on the mathematics, which is good for programmers who don't want to get involved with theory. The applets which implement the data structures are particularly nice.

As mentioned in a previous review, trees are not covered well in this book, but most introductory books don't cover them well either. I don't expect to see an analysis of AVL or red-black trees in an introductory book (Cormen's text, which is the standard for grad school, doesn't explain trees well either). In fact, only Schaffer's book does a creditable job of explaining AVL trees but the implementation of the code isn't the greatest. But for linked lists, stacks,queues, and the like, there are few books that are the equal of this one. Buy the book and you'll pass your DS&A class with flying colors!

This book is a very accessible text on the subject of data structures and algorithms using Java as the implementation language. I found the book to cover things excellently. The author is very efficient and handles these topics without being either too wordy or not giving enough information. The book approaches the subject from what I would call a non-academic angle. The coverage of Big-O notation is non-mathematicall. The author explains the Big-O speed of each data structure or algorithm but does not go into detail about the mathematical basis of such a number. One falling point for some may be the lack of exercizes. I, for one, did not miss these but if you are looking for a book with them, you'll have to look elsewhere. Overall, I highly recommend this book, especially for someone new to the subject. One last point, while the author fails to give any Java implementation for Red-Black trees, this is the only place in the book where he does so. He clearly explains his reasoning for doing as he does--the subject is quite complicated and the code for it immense. He does, however, give a good theoretical explanation of the subject.

I give this book 5 stars. 1. It has a great Table of Contents and Index. Finding topics is a breeze. 2. The explanations for the various data structures presented were outstanding. Explanations were built using simple words and short sentences which facilitates grasping new concepts and definitions. When new words were introduced, their meanings were thoroughly and simply explained. It is a good read. 3. Every data structure and its mechanisms were represented by drawings of colored objects that represented the various data structures. It made visualization of abstract concepts a breeze. This book has the best pictorial representations of Data Structures I that I have seen. (I reviewed over 14 textbooks. Most were didactic regurgitations of either Knuth's tome or Weiss, i.e., difficult to read, appear written for an audience of academics, not students.) 4.The book is very well made. I used it every day for 4 months and it showed no signs of wear and tear. Several other books had pages falling off of their backing withing two weeks of purchase. I returned those books. This book will be will me for decades. 5. The CD included with the book is quite good, and the price of this book was far better than other books. It is an excellent value. Why did I need a book about Data Structures? One required course that I took for my CSCI degree was Data Structures. The book chosen by the CSCI department for our course in Data Structures was "Data Structures & Algorithm Analysis in Java " by Mark Allen Weiss. I reviewed it in detail and found that it was not written in a easy to understand format. Also, it did not include enough diagrams to help me grasp abstract concepts. After reviewing this book, "Data Structures And Algorithms in Java" I purchased it and used it exclusively. It was essential to helping me grasp the concepts of how B-Trees and other structures operate and when they are indicated for use. This book is one of the reasons I got an "A".

When I started studying data structures, I was quite taken aback by the descriptions given in my college textbook. The examples were convoluted and shied from giving the reader an understanding of the basic concepts. Rather, it chose to focus purely on algorithmic analysis. That approach required too many mathematical proofs and other complex notation. Fortunately for me, this gem by Lafore came to the rescue.

Lafore's illustration of data structures is concise and easy to follow. In each section the data structure is discussed in general and then further dissected into easily understandable subsections. An added benefit is that each chapter has Java code that illustrates the main functions of each data structure discussed. The code is included on a CD that also contains interactive Java Applets. I found that the applets really helped illustrate how some of the more complex structures work.

There is no code in the chapter on Red-Black trees or in the chapter on 2-3-4 Trees and external storage. This is okay however, since presentation of the code might have consumed too much space and have been difficult to follow (Fortunately, There are insightful applets for these topics). My only regret is that the book doesn't give as much in-depth information on certain functions of B-trees and B+ Trees as it does on the other topics. More than less likely this is a little (too?) picky on my part.

Overall a great book to get if you are interested in learning essential Data Structures.

I did a course on data structures in university last semester, this was not the official text book for our course, but I bought it and found it to be very good.

This book features numerous examples, to help students understand this complicated subject. There is a cd which has example applets (screen shots are often used in the book).

The text is clear and easily understandable by anyone taking a Comp Sci course.

Compared to other data structures (java) books I have seen, this book rules.

I got a very good exam mark and for this I am most grateful to Mitchell Waite and Robert Lafore for writing this book.

I bought this book a couple of years ago as a reference for a data structures class I was taking. While the teacher used another book (based on C++) for teaching his class, it was MUCH easier to understand these subject with this book. The different structures and algorithms are clearly presented and implemented and the workshop applet included are crucial for understanding visually these algorithms and structures.
Still, it lacks examples that truly take power of different features that Java has that makes creating these structures easier. For example, the stack data structure is explained using an integer array, which is fine for structures with an specific size, but lack the expandabilty that features like inheritance, encapsulation and polymorphism can offer. If instead of using an integer array, a class with a generic Object (which is the superclass of all the classes in Java) class was used, all the examples in this book would be prepared for real world situations, instead of readiness for an specific data type and/or size.
Nevertheless, I still recomend this book to everyone that wants to learn data structures easily with little pain, but lots of gain.

Is there a perfect book out there on data structures using Java? No, but this book by Lafore is the best among the lot especially for students trying to learn the stuff. This book is the exact opposite of the widely used book by Tamassia&Goodrich (T&G) - that is, Lafore covers data structures in a non-mathematical, non-technical way without using formal proofs and abstract mathematical definitions. This makes it very readable and understandable especially when compared to T&G. It covers all the major topics you're likely to see in your data structures course: arrays, stacks, linked lists, queues, sorting algorithms, trees, heaps and hash tables. The last chapter - When to Use What - is excellent. Distills the whole topic into just a few pages.

Complaints: This book gives very short shrift to big O notation IMO. And Lafore really takes the easy way out with heaps - he uses an array (Ugh!). Come on, Lafore, you should have used a tree for this ! He doesn't cover AVL trees at all so you'll have to look elsewhere for that. Also, ... the source code isn't 'generic' enough - he implements many data structures to hold a specific type instead of allowing them to hold generic Objects. There are no end of chapter exercises so I don't know if it could be used as a regular class text. The applets on the disc are instructive, though.

If you could combine the topic coverage of T&G (along with just a bit of their formalism) and Lafore's readablity you'd have the perfect teaching book on data structures using Java.

This is a wonderful programming book with great text and nice diagrams. As a bonus you get a CD with Applets that visually implement the algorithim so you can see it "in action". While the implementations are in Java, the code is presented in a way that the code is not the focus - the concepts are, so it will even work if you have a different programming background. The Java implementations are very good, and the code is presented well.

This book focuses on data structures, so you won't find much information on String searching, pattern matching, parsing, file compression, or mathematical-type algorithims (random number generators,hashing (some simple hashing is presented), etc). It would be great if these other topics were found in another volume.

The great thing about this book is that it focuses on how the datastructures are implemented without getting bogged down on the "mathematics" behind the performance or other characteristics. If you have read any book by Sedgewick or Knuth you know what what I am talking about (note that those books are also great but focus on a different audience).

The only thing that would make this book better would be if it had exercises and solutions for students to implement.

Buy this.

This book is outstanding. I am very familiar with data structures and I am fluent in several computer languages, but not Java. I was looking for a book that would let me quickly implement the data structures I needed in Java. This book is perfect for that. LaFore is an excellent writer. The examples are short and focussed on particular data structures. The code is very easy to read, modify, and combine. And, unlike many other books, LaFore's code is debugged and works right out of the book. I purchased several books on data structures in Java, and this is the one I use. My recommendation: buy it.

This book provides a great introductions to Data Structures and Algorithms using the Java programming languages. I picked this book up before taking a course on the subject and found it very easy to follow along. My text for the course in contrast was very dry and full of dry mathematical concepts and proofs which the average software developer need not bother with. The workshop applets provide an excellent method of viewing the algorithms in action. I highly recommend this book to anyone interested in DS&A who may be intimidated by some of the concepts involved.