Librería Portfolio Librería Portfolio

Búsqueda avanzada

TIENE EN SU CESTA DE LA COMPRA

0 productos

en total 0,00 €

DATA STRUCTURES AND ABSTRACTIONS WITH JAVA, GLOBAL EDITION 4E
Título:
DATA STRUCTURES AND ABSTRACTIONS WITH JAVA, GLOBAL EDITION 4E
Subtítulo:
Autor:
HENRY, T
Editorial:
PEARSON
Año de edición:
2015
Materia
JAVA
ISBN:
978-1-292-07718-5
Páginas:
936
83,50 €

 

Sinopsis

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 organization: Material is organized 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.



Introduction
Prelude: Designing Classes
Encapsulation
Specifying Methods
Comments
Preconditions and Postconditions
Assertions
Java Interfaces
Writing an Interface
Implementing an Interface
An Interface as a Data Type
Extending an Interface
Interfaces Versus Abstract Classes
Named Constants Within an Interface
Choosing Classes
Identifying Classes
CRC Cards
The Unifed Modeling Language
Reusing Classes
Chapter 1: Bags
The Bag
A Bag's Behaviors
Specifying a Bag
An Interface
Using the ADT Bag
Using an ADT Is Like Using a Vending Machine
The ADT Set
Java Interlude 1: Generics
Generic Data Types
Generic Types Within an Interface
Generic Classes
Chapter 2: Bag Implementations That Use Arrays
Using a Fixed-Size Array to Implement the ADT Bag
An Analogy
A Group of Core Methods
Implementing the Core Methods
Making the Implementation Secure
Testing the Core Methods
Implementing More Methods
Methods That Remove Entries
Using Array Resizing to Implement the ADT Bag
Resizing an Array
A New Implementation of a Bag
The Pros and Cons of Using an Array to Implement the ADT Bag
Java Interlude 2: Exceptions
The Basics
Handling an Exception
Postpone Handling: The throws Clause
Handle It Now: The try-catch Blocks
Multiple catch Blocks
Throwing an Exception
Chapter 3: A Bag Implementation That Links Data
Linked Data
Forming a Chain by Adding to Its Beginning
A Linked Implementation of the ADT Bag
The Private Class Node
An Outline of the Class LinkedBag
Defning Some Core Methods
Testing the Core Methods
The Method getFrequencyOf
The Method contains
Removing an Item from a Linked Chain
The Methods remove and clear
A Class Node That Has Set and Get Methods
The Pros and Cons of Using a Chain to Implement the ADT Bag
Chapter 4: The Effciency of Algorithms
Motivation
Measuring an Algorithm's Effciency
Counting Basic Operations
Best, Worst, and Average Cases
Big Oh Notation
The Complexities of Program Constructs
Picturing Effciency
The Effciency of Implementations of the ADT Bag
An Array-Based Implementation
A Linked Implementation
Comparing the Implementations
Chapter 5: Stacks
Specifcations of the ADT Stack
Using a Stack to Process Algebraic Expressions
A Problem Solved: Checking for Balanced Delimiters in an Infx Algebraic Expression
A Problem Solved: Transforming an Infx Expression to a Postfx Expression
A Problem Solved: Evaluating Postfx Expressions
A Problem Solved: Evaluating Infx Expressions
The Program Stack
Java Class Library: The Class Stack
Chapter 6: Stack Implementations
A Linked Implementation
An Array-Based Implementation
A Vector-Based Implementation
Java Class Library: The Class Vector
Using a Vector to Implement the ADT Stack
Chapter 7: Recursion
What Is Recursion?
Tracing a Recursive Method
Recursive Methods That Return a Value
Recursively Processing an Array
Recursively Processing a Linked Chain
The Time Effciency of Recursive Methods
The Time Effciency of countDown
The Time Effciency of Computing xn
A Simple Solution to a Diffcult Problem
A Poor Solution to a Simple Problem
Tail Recursion
Indirect Recursion
Using a Stack Instead of Recursion
Java Interlude 3: More About Generics
The Interface Comparable
Generic Methods
Bounded Type Parameters
Wildcards
Bounded Wildcards
Chapter 8: An Introduction to Sorting
Organizing Java Methods That Sort an Array
Selection Sort
Iterative Selection Sort
Recursive Selection Sort
The Effciency of Selection Sort
Insertion Sort
Iterative Insertion Sort
Recursive Insertion Sort
The Effciency of Insertion Sort
Insertion Sort of a Chain of Linked Nodes
Shell Sort
The Java Code
The Effciency of Shell Sort
Comparing the Algorithms
Chapter 9: Faster Sorting Methods
Merge Sort
Merging Arrays
Recursive Merge Sort
The Effciency of Merge Sort
Iterative Merge Sort
Merge Sort in the Java Class Library
Quick Sort
The Effciency of Quick Sort
Creating the Partition
Implementing Quick Sort
Quick Sort in the Java Class Library
Radix Sort
Pseudocode for Radix Sort
The Effciency of Radix Sort
Comparing the Algorithms
Java Interlude 4: More About Exceptions
Programmer-Defned Exception Classes
Inheritance and Exceptions
The finally Block
Chapter 10: Queues, Deques, and Priority Queues
The ADT Queue
A Problem Solved: Simulating a Waiting Line
A Problem Solved: Computing the Capital Gain in a Sale of Stock
Java Class Library: The Interface Queue
The ADT Deque
A Problem Solved: Computing the Capital Gain in a Sale of Stock
Java Class Library: The Interface Deque
Java Class Library: The Class ArrayDeque
The ADT Priority Queue
A Problem Solved: Tracking Your Assignments
Java Class Library: The Class PriorityQueue
Chapter 11: Queue, Deque, and Priority Queue Implementations
A Linked Implementation of a Queue
An Array-Based Implementation of a Queue
A Circular Array
A Circular Array with One Unused Location
Circular Linked Implementations of a Queue
A Two-Part Circular Linked Chain
Java Class Library: The Class AbstractQueue
A Doubly Linked Implementation of a Deque
Possible Implementations of a Priority Queue
Chapter 12: Lists
Specifcations for the ADT List
Using the ADT List
Java Class Library: The Interface List
Java Class Library: The Class ArrayList
Chapter 13: A List Implementation That Uses an Array
Using an Array to Implement the ADT List
An Analogy
The Java Implementation
The Effciency of Using an Array to Implement the ADT List
Chapter 14: A List Implementation That Links Data
Operations on a Chain of Linked Nodes
Adding a Node at Various Positions
Removing a Node from Various Positions
The Private