Data Structures in Java [Paperback]

Thomas A. Standish (Author)

Book Description

ISBN-10: 020130564X | ISBN-13: 978-0201305647 | Publication Date: August 22, 1997

Using Java 1.1, this book teaches the fundamentals of data structures and algorithms. With this exciting new language, Tim Standish takes a fresh look at the subject matter. New challenges arise any time a new language is used, and the author meets these challenges. For example, although Java is a language without explicit pointers, this book offers pointer diagrams to help students visualize, reason about, and understand this major Data Structures topic. Standish's clear presentation helps readers tie the many concepts of data structures together with recurring themes. Central ideas-such as modularity, levels of abstraction, efficiency, and tradeoffs-serve as integrators in the book in order to tie the material together conceptually and to reveal its underlying unity and interrelationships.

Editorial Reviews

From the Back Cover

Using Java™ 1.1, Professor Thomas A. Standish teaches the fundamentals of data structures and algorithms. With this exciting new language, Standish takes a fresh look at the subject matter. New challenges arise any time a new language is used, and the author meets these challenges. For example, although Java is a language without explicit pointers, this book offers pointer diagrams to help students visualize, reason about, and understand this major Data Structures topic. Standish's clear presentation helps readers tie the many concepts of data structures together with recurring themes. Central ideas - such as modularity, levels of abstraction, efficiency, and tradeoffs - serve as integrators in the book in order to tie the material together conceptually and to reveal its underlying unity and interrelationships.

Highlights

• Reviews the fundamentals of object-oriented programming and Java in Chapter 2 and Appendix A, allowing students with no prior knowledge of Java to get up and running quickly.
• Creates a Java applet with a simple GUI in Chapter 2.
• Covers recursion early and carefully in Chapter 4 to help students grasp this challenging concept.
• Includes an introduction to modularity and data abstraction concepts in Chapter 5, and coverage of key software engineering concepts and skills in Appendix C.
• Contains common pitfall sections at the end of each chapter to help students recognize and avoid potential dangers.

** Instructor's materials are available from your sales rep. If you do not know your local sales representative, please call 1-800-552-2499 for assistance, or use the Addison Wesley Longman rep-locator at http://hepg.awl.com/rep-locator.

020130564XB04062001

About the Author

Thomas A. Standish is the chairman of computer science at the University of California, Irvine. In 1990-91, he became the fourth winner of University of California Irvine's Distinguished Faculty Lectureship for Teaching, the campus' highest distinction for teaching excellence. He has also been a co-winner of his department's best-teacher award, chosen by the popular vote of University of California Irvine undergraduate computer science students.

020130564XAB04062001

Product Details

• Paperback: 555 pages
• Publisher: Addison Wesley (August 22, 1997)
• Language: English
• ISBN-10: 020130564X
• ISBN-13: 978-0201305647
• Product Dimensions: 9.6 x 8.4 x 1.1 inches
• Shipping Weight: 2.5 pounds
• Average Customer Review: 3.7 out of 5 stars  See all reviews (11 customer reviews)
• Amazon Best Sellers Rank: #291,481 in Books (See Top 100 in Books)
  • #37 in Books > Computers & Technology > Programming > Algorithms > Data Structures

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

6 of 6 people found the following review helpful:

4.0 out of 5 stars This book is thorough and clear, but it needs more material, July 2, 1999

By A Customer

This review is from: Data Structures in Java (Paperback)

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!

4 of 4 people found the following review helpful:

4.0 out of 5 stars Informative & well-written, but needs more solutions, February 29, 2000

By 

Rick Dulaney (Washington, DC) - See all my reviews

This review is from: Data Structures in Java (Paperback)

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.

2 of 2 people found the following review helpful:

3.0 out of 5 stars it's decent, but too expensive, March 14, 1999

By 

Louis Yang - See all my reviews

This review is from: Data Structures in Java (Paperback)

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