Data Structures and Abstractions with Java, Global Edition (4e) : 9781292077185

Data Structures and Abstractions with Java, Global Edition (4e)

Carrano, Frank & Henry, Timothy
 
Edition
 
4
ISBN
 
9781292077185
ISBN 10
 
1292077182
Published
 
24/05/2015
Published by
 
Pearson Higher Ed USA
Pages
 
936
Format
 
Available on demand
 
Title type
Book + Access Code
$132.99
 
 
Title type
 
$60.00
 
 
Description

 

Data Structures and Abstractions with Java is suitable for one- or two-semester courses in data structures (CS-2) in the departments of Computer Science, Computer Engineering, Business, and Management Information Systems.

This is the most student-friendly data structures text available that introduces ADTs in individual, brief chapters – each with pedagogical tools to help students master each concept. Using the latest features of Java, this unique object-oriented presentation makes a clear distinction between specification and implementation to simplify learning, while providing maximum classroom flexibility.

Teaching and Learning Experience

This book will provide a better teaching and learning experience–for you and your students. It will help:

  • Aid comprehension and facilitate teaching with an approachable format and content organisation: Material is organised into small segments that focus a reader’s attention and provide greater instructional flexibility.
  • Keep your course current with updated material: Content is refreshed throughout the book to reflect the latest advancements and to refine the pedagogy. All of the Java code is Java 8 compatible.
  • Support learning with student-friendly pedagogy: In-text and online features help students master the material.

 

Table of contents
  • Introduction
  • Chapter 1: Bags
  • Chapter 2: Bag Implementations That Use Arrays
  • Chapter 3: A Bag Implementation That Links Data
  • Chapter 4: The Effciency of Algorithms
  • Chapter 5: Stacks
  • Chapter 6: Stack Implementations
  • Chapter 7: Recursion
  • Chapter 8: An Introduction to Sorting
  • Chapter 9: Faster Sorting Methods
  • Chapter 10: Queues, Deques, and Priority Queues
  • Chapter 11: Queue, Deque, and Priority Queue Implementations
  • Chapter 12: Lists
  • Chapter 13: A List Implementation That Uses an Array
  • Chapter 14: A List Implementation That Links Data
  • Chapter 15: Iterators for the ADT List
  • Chapter 16: Sorted Lists
  • Chapter 17: Inheritance and Lists
  • Chapter 18: Searching
  • Chapter 19: Dictionaries
  • Chapter 20: Dictionary Implementations
  • Chapter 21: Introducing Hashing
  • Chapter 22: Hashing as a Dictionary Implementation
  • Chapter 23: Trees
  • Chapter 25: A Binary Search Tree Implementation
  • Chapter 26: A Heap Implementation
  • Chapter 27: Balanced Search Trees
  • Chapter 28: Graphs
  • Chapter 29: Graph Implementations
New to this edition

Keep your course current with updated material

  • Class design is covered in a new Prelude, which is positioned between the Introduction and Chapter 1.
  • Safe and secure programming is a new topic introduced in Chapter 2 and discussed in new Security Notes that are relevant to the implementations of the ADTs. The code throughout the book has been revised to reflect this subject matter.
  • Beginning with stacks in Chapter 5, most ADT methods now indicate failure by throwing an exception. Methods only return null in such cases when null cannot be a data value within a collection.
  • Additional coverage of generics treats generic methods and bounded types.
  • Illustrations show objects specifically instead of as values within nodes or array elements.
  • Vector-based implementations of the ADT list and queue are no longer covered, but are left as programming projects.
  • Line numbers now appear in program listings.
  • All of the Java code is Java 8 compliant.

Support learning with student-friendly pedagogy

  • Java Interludes – Relevant aspects of Java are covered in new Java Interludes that occur throughout the text. Java Interlude topics include: Generics; Exceptions; More About Generics; More About Exceptions; Iterators; Mutable and Immutable Objects; Inheritance; Generics Once Again; and Cloning.
  • Additional Design Decisions continue to present the options one has when specifying and implementing particular ADTs and provide the rationale behind our choices.
  • The complete instructor support package now includes a Test Bank.

Features & benefits

Aid comprehension and facilitate teaching with an approachable format and content organisation

  • Material is organised into small segments that focus a reader’s attention and provide greater instructional flexibility.
  • Unique object-oriented presentation separates the specification and use of a data collection from its implementation, and presents each in their own brief chapters.
  • Each ADT is introduced in its own chapter, including examples or applications. To make it easier for students to learn and retain each ADT concept, Carrano covers specification and implementation of each ADT in separate, but consecutive chapters. This grants instructors flexibility in their teaching approach, while retaining the advantage of separation of specification and implementation.
  • Flexible and extensive assignments include a variety of exercises and programming projects that can be used in- class or assigned as homework, as well as self-test questions throughout each chapter.
  • The visually appealing, attractive design includes many figures and simple illustrations to provide students with a more thorough understanding of the concepts. 

 

Keep your course current with updated material

  • NEW: Class design is covered in a new Prelude, which is positioned between the Introduction and Chapter 1.
  • NEW: Safe and secure programming is a new topic introduced in Chapter 2 and discussed in new Security Notes that are relevant to the implementations of the ADTs. The code throughout the book has been revised to reflect this subject matter.
  • UPDATED: Beginning with stacks in Chapter 5, most ADT methods now indicate failure by throwing an exception. Methods only return null in such cases when null cannot be a data value within a collection.
  • UPDATED: Additional coverage of generics treats generic methods and bounded types.
  • UPDATED: Illustrations show objects specifically instead of as values within nodes or array elements.
  • UPDATED: Vector-based implementations of the ADT list and queue are no longer covered, but are left as programming projects.
  • NEW: Line numbers appear in program listings.
  • UPDATED: All of the Java code is Java 8 compliant.

 

Support learning with student-friendly pedagogy

  • Help reinforce and test student understanding for sustained learning
    • NEW: Java Interludes – Relevant aspects of Java are covered in new Java Interludes that occur throughout the text. Java Interlude topics include: Generics; Exceptions; More About Generics; More About Exceptions; Iterators; Mutable and Immutable Objects; Inheritance; Generics Once Again; and Cloning.
    • Notes – Important ideas are presented or summarised in highlighted paragraphs that are meant to be read in line with the surrounding text.
    • Programming Tips – Suggestions to improve or facilitate programming are featured as soon as they become relevant.
    • Examples – Numerous examples illuminate new concepts.
    • Self-Test Questions – Questions are integrated within the text, throughout each chapter, to reinforce the concept just presented and help students understand the material. The reader must pause and reflect on the material to answer the question(s). Solutions to the self-test questions are provided at the end of each chapter.
    • Exercises and Programming Projects – Further practice is available by solving the exercises and programming projects at the end of each chapter.
  • Teach students how to think critically about which DS is best to solve particular problems
    • A Problem Solved – Large examples are presented in the form of A Problem Solved,in which a problem is posed and its solution is discussed, designed, and implemented.
    • Design Decisions – To give readers insight into the design choices that one could make when formulating a solution, “Design Decision” elements lay out such options, along with the rationale behind the choice made for a particular example. These discussions are often in the context of one of the A Problem Solved examples.
      • UPDATED: Additional Design Decisions continue to present the options one has when specifying and implementing particular ADTs and provide the rationale behind our choices.