Java Structures: Data Structures in Java for the Principled Programmer (2nd edition)

View Larger

Java Structures: Data Structures in Java for the Principled Programmer (2nd edition)

  • by Duane Bailey
  • Filetype: pdf
  • Filesize: 2.9 MB
  • Language: English


  • pages


  • bookmarked


  • paginated


  • vector


  • searchable



Java Structures: Data Structures in Java for the Principled Programmer (2nd edition)
By Duane Bailey

  • Publisher:   McGraw-Hill Science/Engineering/Math
  • Number Of Pages:   528
  • Publication Date:   2002-07-26
  • ISBN-10 / ASIN:   0072399090
  • ISBN-13 / EAN:   9780072399097

Product Description:

The second edition of Duane Bailey's Java Structures considers the design, implementation, and use of data structures using Java 2. The structure package, a collection of nearly 100 different classes implementing a wide variety of data structures, has been the basis of Java Structures for more than five years. Thousands of faculty, students, researchers, industrial and recreational programmers have investigated this lean and well tested approach to data structure design.

In this edition, the text develops a heavily tested package that is independent of but consistent with the Collection package offered by Sun. In many cases, the variety of implementations provides the programmer choices of data structure that are not available with the Collection system. For those curricula that make use of the Collection package, the structure package can be easily integrated into existing applications. All classes are fully documented and make consistent use of pre- and post-conditioning, and include support for assertion testing.

The second edition also brings a wealth of new resources, including a large number of new and original exercises and drill problems. Throughout the text, exercises appear in the running text to direct a deeper consideration of subtle issues by students. Perhaps the most innovative feature (first found in Bailey's Java Elements) is the inclusion of more than a dozen original lab exercises that focus on interesting and often classic problems of computer science.

Summary: Just what you're looking for
Rating: 5

A great resource for data structures. Well supported via the Web with all classes discussed in the text. Virtually error free code. One of my best purchases.

Summary: Just Amazing
Rating: 5

This book is the solution I've been searching my whole life. It goes to the point and clears any doubts that you may have.

Summary: Excellent book for C++ programmers learning Java
Rating: 5

As a C++ programmer familiar with MFC, I bought this book to learn Java. I was already familiar with data structures and wanted to see how Java works with a familiar subject. I was very pleased to find that the book was well organized and well written. It was an enjoyable read and when I was done I was able to design my first test applets with ease and confidence. Thanks for making the book with a hard cover; it really is more comfortable.

Java is evolving so rapidly, that a reader should not expect to learn "everything about Java" nor everything about data structures from this book. Nevertheless, the book is valuable for accelerating the learning curve.

Thanks, Duane, for writing it.

Summary: Excellent Work
Rating: 5

There exist many programming books which are simply, fluff, assuming that one is able to make the distinction. This book is one of the EXCEPTIONS among a sea of badly written books full of bugs. It is a great disservice to the programming community to defile such excellent work. Under what authority, if I may humbly ask, can one review a subject in which one has not the mere required pre-requisite ___that is at the minimum, a base` reading knowledge of (OOP).

I think, that the book is excelllent. May the tradition continue.

Summary: I slept with this book under my pillow last night
Rating: 5

Java Structures has been an invaluable companion on my journey through the strangely beautiful world of data structures at a small anonymous liberal arts college in the Berkshire region of Massachusetts. Last night I slept with this book under my pillow.

Summary: Horrible Textbook
Rating: 1

I am a student using this book for a CS2 course. This book is horrible. My main complaints are the organization of everything.

The questions at the end of each chapter don't indicate what section you may find the answers, and sometimes they refer to code in an entirely different chapter. Apparently the author assumes that you memorize every bit of code he explains in each chapter. While the reading isn't all that bad, it is poorly organized as well.

For example Recursion: When the book explains recursion, it gives you one example of turning a non-recursive function into a recursive function. Then, it assumes that you will know how to turn any non-recursive function into a recursive function. It doesn't really give you any steps on doing so, just kind of assumes that you can figure it out.

Since I recently took a technical writing class, this book disgusts me even more. Poor layout, poor design, and just overall a horrible book for a CS2 class. My instructor seems to like the book because the author actually has a sense of humor.

If you want a book that teaches you the fundamentals of Java Data Structures, then look elsewhere. If you want to laugh while reading a book, buy this one.

Summary: Excellent - '2nd semester' text
Rating: 5

This is a great book if you are a competent programmer, perhaps with some O-O experience and some procedural/functional language experience. It is not for the beginner programmer, as lots of 'trivial' concepts are glossed over - which may confuse some.

It is used for 2nd semester CS, after a 1st semester course which taught Java.

Summary: Confusing
Rating: 2

As a computer science student learning data structures, I found this book to be incredibly confusing for a beginner. The examples provided are not explained well. The reader is often left to guess and fill in details. It seems like many important details were left out. If you were to try his examples using a compiler, they would never work because the author omits to tell you some important piece of info. Pieces of code appear to be just thrown in without adequate explanation of how they relate to other code. I was thouroughly frustrated with this book.

Summary: Good but flawed
Rating: 3

I like this book because it gives a concise presentation of the material, and contains lots of good exercises. It does contain some bad mistakes, however (such as a complete misunderstanding of what is meant by tail recursion and false statements about Java). Possibly there is also too much unexplained code.

Summary: Smirks and Curt
Rating: 1

This book was not very good. Initially, like alot of software books, the author's smug comments were not irritating. By the end of the book they were unnerving. The biggest beef I had with this text was that the author does not offer sufficient explanations for the code examples. He assumes you can just read it and then understand it. Also, in several chapters rather than presenting the facts then illustrating them in a complex example he does exactly the opposite! This did nothing but serve to confuse the issue.

The author's goal is commendable: attempt to be brief and too the point. However, unfortunately this book suffers due to little or no supporting narrative to accompany the code.

The book reminds me of a professor who is teaching a beginning class but assumes you can figure out the details on your own. The professor forgets that you don't know the details yet and its his job to give them to you.

I did not like this book.

Summary: This is not a very good book
Rating: 1

This book is being used as the text for a CS2 level course I am taking. Everyone in the class finds the book too confusing and complicated to be useful. I agree with them, even though I have nearly 20 years of experience in a variety of languages (none of them OO, however). Even the instructor admitted upfront that he was not pleased with it. We are all turning to other books to more clearly explain how to implement structures in Java. I have even found an old Pascal book that does a far better job relating the concepts. If you are already fairly experienced in Java (or C++), this book may be useful; otherwise, look elsewhere.