Home > Store

Data Structures and Abstractions with Java

Register your product to gain access to bonus material or receive a coupon.

Data Structures and Abstractions with Java

Book

  • Sorry, this book is no longer in print.
Not for Sale

About

Features

  • Designed and built from the ground up with Java and objects in mind.
    • Provides instructors and students with a carefully crafted and class-tested approach for teaching ADTs and objects with Java.

  • Separation of specification and implementation of ADTs into individual but consecutive chapters.
    • Allows students to learn the distinction between design specification and implementation. Allows instructor to cover topics sequentially or delay coverage of implementation chapters.

  • Chapters organized into sections, and sections into numbered segments.
    • Helps students focus their attention on one issue at a time. Gives students visual cues to identify the segments via segment numbers and the design of the book. Encourages students to master each segment before continuing and gives them a sense of progress and organization.

  • Numerous carefully provided figures.
    • Helps make the presentation much more visual and less imposing then other books.

  • Highlighted notes.
    • Emphasizes key material and provides supplementary comments.

  • Programming Tips.
    • Gives students additional programming advice.

  • Self-Test Questions throughout chapter—With answers at the back of the book.
    • Encourages students to practice the concepts and helps them discover the implications of what they just read.

  • Better integrated Java coverage with comments within Java code in javadoc style.
    • Shows students the standard documentation style for Java programs.

  • Accompanying CD-ROM.
    • Gives students a visual learning aid beyond the text.

Description

  • Copyright 2003
  • Dimensions: 8" x 10"
  • Pages: 864
  • Edition: 1st
  • Book
  • ISBN-10: 0-13-017489-0
  • ISBN-13: 978-0-13-017489-5

Written for an introductory course in data structures, typically known as CS-2, this book was designed and built from the ground up with Java and objects in mind. Frank Carrano and Walter Savitch provide instructors and students with a carefully crafted and class-tested approach for teaching ADTs and objects with Java. The book's unique design organizes material in short segments and relatively small chapters. This approach makes learning easier and allows for teaching flexibility. The book shows students how to organize their data by using a list, a dictionary, a stack, a queue, and so on. Using these data organizations, students will learn about related techniques for algorithm development.

FEATURES
  • Separates the specification and implementation of ADTs into individual, but consecutive, chapters.
  • Presents short, bite-sized segments that focus attention on one issue at a time.
  • Organizes material into numerous, relatively small chapters that can be covered in various sequences.
  • Presents highlighted notes emphasizing key material and providing supplementary comments.
  • Offers programming tips that give readers additional programming advice.
  • Contains many figures, making presentation more visual and less imposing than other books.
  • Offers self-test questions throughout chapters, with answers in the back of the book.
  • Integrates Java coverage into the presentation, including the javadoc documentation style for Java programs.
  • Features a Prentice Hall Companion Website available at
    http://www.prenhall.com/carrano

Sample Content

Table of Contents



Introduction.


 1. Java Classes.


 2. Creating Classes from Other Classes.


 3. Designing Classes.


 4. Lists.


 5. List Implementations That Use Arrays.


 6. List Implementations That Link Data.


 7. Iterators.


 8. Java's Iterator Interfaces.


 9. The Efficiency of Algorithms.


10. Recursion.


11. An Introduction to Sorting.


12. Faster Sorting Methods.


13. Sorted Lists.


14. Inheritance and Lists.


15. Mutable, Immutable, and Cloneable Objects.


16. Searching.


17. Dictionaries.


18. Dictionary Implementations.


19. Hashing as a Dictionary Implementation.


20. Stacks.


21. Stack Implementations.


22. Queues, Deques, and Priority Queues.


23. Queue, Deque, and Priority Queue Implementations.


24. Trees.


25. Tree Implementations.


26. A Binary Search Tree Implementation.


27. A Heap Implementation.


28. Balanced Search Trees.


29. Graphs.


30. Graph Implementations.


Appendix A: Java Essentials.


Appendix B: Exception Handling.


Appendix C: File I/O.


Appendix D: Documentation and Programming Style.


Appendix E: Java Resources.


Appendix F: Answers to Self-Test Questions.


Inside covers (end papers).


Reserved Words.


Operator Precedence.


Unicode Character Codes.

Updates

Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership