pearson: Data Structures and Abstractions with Java

pearson-java
pearson: Data Structures and Abstractions with Java
ISBN : 978-1-61691-462-2

Lessons

uCertify uses content from well known publishers, instructors, and subject matter experts. They have a minimum of 15 years of experience in their fields. uCertify brings these textbooks to life. It is full of interactive activities that keeps the learner engaged. uCertify brings all available learning resources for a topic in one place so that the learner can efficiently learn without going to multiple places. Challenge questions are also embedded in the chapters so learners can attempt those while they are learning about that particular topic. This helps them grasp the concepts better because they can go over it again right away which improves learning. Learners can do Flashcards, Exercises, Quizzes and Labs related to each chapter. At the end of every lesson, uCertify courses guide the learners on the path they should follow.

uCertify platform supports 50+ different types of interactive activities, connect the idea, or try it yourself lab activities embedded throughout its course. These interactive activities keeps learners engaged and makes learning fun.

Here's What You Get

Exercises Flashcards

Each lesson comes with Exercises & Flashcards. There is no limit to the number of times learners can attempt these. Exercises come with detailed remediation, which ensures that learners are confident on the topic before proceeding. Flashcards help master the key concepts.

Exercise Questions
308+
Flashcards
206+
Lessons
30+

Table of Content

Here's What you will Learn

Lesson 1: Bags

  • The Bag
  • Specifying a Bag
  • Using the ADT Bag
  • Using an ADT Is Like Using a Vending Machine
  • Java Class Library: The Interface Set
  • Chapter Summary
  • Exercises
  • Projects

Lesson 2: Bag Implementations That Use Arrays

  • Using a Fixed-Size Array to Implement the ADT Bag
  • Using Array Resizing to Implement the ADT Bag
  • The Pros and Cons of Using an Array to Implement the ADT Bag
  • Chapter Summary
  • Exercises
  • Projects

Lesson 3: A Bag Implementation That Links Data

  • Linked Data
  • A Linked Implementation of the ADT Bag
  • Removing an Item from a Linked Chain
  • A Class Node That Has Set and Get Methods
  • The Pros and Cons of Using a Chain to Implement the ADT Bag
  • Chapter Summary
  • Exercises
  • Projects

Lesson 4: The Efficiency of Algorithms

  • Motivation
  • Measuring an Algorithm's Efficiency
  • Big Oh Notation
  • Picturing Efficiency
  • The Efficiency of Implementations of the ADT Bag
  • Chapter Summary
  • Exercises
  • Projects

Lesson 5: Stacks

  • Specifications of the ADT Stack
  • Using a Stack to Process Algebraic Expressions
  • The Program Stack
  • Java Class Library: The Class Stack
  • Chapter Summary
  • Exercises
  • Projects

Lesson 6: Stack Implementations

  • A Linked Implementation
  • An Array-Based Implementation
  • A Vector-Based Implementation
  • Chapter Summary
  • Exercises
  • Projects

Lesson 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 Efficiency of Recursive Methods
  • A Simple Solution to a Difficult Problem
  • A Poor Solution to a Simple Problem
  • Tail Recursion
  • Indirect Recursion
  • Using a Stack Instead of Recursion
  • Chapter Summary
  • Exercises
  • Projects

Lesson 8: An Introduction to Sorting

  • Organizing Java Methods That Sort an Array
  • Selection Sort
  • Insertion Sort
  • Shell Sort
  • Comparing the Algorithms
  • Chapter Summary
  • Exercises
  • Projects

Lesson 9: Faster Sorting Methods

  • Merge Sort
  • Quick Sort
  • Radix Sort
  • Comparing the Algorithms
  • Chapter Summary
  • Exercises
  • Projects

Lesson 10: Queues, Deques, and Priority Queues

  • The ADT Queue
  • The ADT Deque
  • The ADT Priority Queue
  • Chapter Summary
  • Exercises
  • Projects

Lesson 11: Queue, Deque, and Priority Queue Implementations

  • A Linked Implementation of a Queue
  • An Array-Based Implementation of a Queue
  • A Vector-Based Implementation of a Queue
  • Circular Linked Implementations of a Queue
  • Java Class Library: The Class AbstractQueue
  • A Doubly Linked Implementation of a Deque
  • Possible Implementations of a Priority Queue
  • Chapter Summary
  • Exercises
  • Projects

Lesson 12: Lists

  • Specifications for the ADT List
  • Using the ADT List
  • Java Class Library: The Interface List
  • Java Class Library: The Class ArrayList
  • Chapter Summary
  • Exercises
  • Projects

Lesson 13: List Implementations That Use Arrays

  • Using an Array to Implement the ADT List
  • Using a Vector to Implement the ADT List
  • Chapter Summary
  • Exercises
  • Projects

Lesson 14: A List Implementation That Links Data

  • Operations on a Chain of Linked Nodes
  • Beginning the Implementation
  • Continuing the Implementation
  • A Refined Implementation
  • The Efficiency of Using a Chain to Implement the ADT List
  • Java Class Library: The Class LinkedList
  • Chapter Summary
  • Exercises
  • Projects

Lesson 15: Iterators

  • What Is an Iterator?
  • The Interface Iterator
  • A Separate Class Iterator
  • An Inner Class Iterator
  • Why Are Iterator Methods in Their Own Class?
  • The Interface ListIterator
  • Java Class Library: The Interface Iterable
  • Chapter Summary
  • Exercises
  • Projects

Lesson 16: Sorted Lists

  • Specifications for the ADT Sorted List
  • A Linked Implementation
  • An Implementation That Uses the ADT List
  • Chapter Summary
  • Exercises
  • Projects

Lesson 17: Inheritance and Lists

  • Using Inheritance to Implement a Sorted List
  • Designing a Base Class
  • An Efficient Implementation of a Sorted List
  • Chapter Summary
  • Exercises
  • Projects

Lesson 18: Searching

  • The Problem
  • Searching an Unsorted Array
  • Searching a Sorted Array
  • Searching an Unsorted Chain
  • Searching a Sorted Chain
  • Choosing a Search Method
  • Chapter Summary
  • Exercises
  • Projects

Lesson 19: Dictionaries

  • Specifications for the ADT Dictionary
  • Using the ADT Dictionary
  • Java Class Library: The Interface Map
  • Chapter Summary
  • Exercises
  • Projects

Lesson 20: Dictionary Implementations

  • Array-Based Implementations
  • Vector-Based Implementations
  • Linked Implementations
  • Chapter Summary
  • Exercises
  • Projects

Lesson 21: Introducing Hashing

  • What Is Hashing?
  • Hash Functions
  • Resolving Collisions
  • Chapter Summary
  • Exercises
  • Projects

Lesson 22: Hashing as a Dictionary Implementation

  • The Efficiency of Hashing
  • Rehashing
  • Comparing Schemes for Collision Resolution
  • A Dictionary Implementation That Uses Hashing
  • Java Class Library: The Class HashMap
  • Java Class Library: The Class HashSet
  • Chapter Summary
  • Exercises
  • Projects

Lesson 23: Trees

  • Tree Concepts
  • Traversals of a Tree
  • Java Interfaces for Trees
  • Examples of Binary Trees
  • Examples of General Trees
  • Chapter Summary
  • Exercises
  • Projects

Lesson 24: Tree Implementations

  • The Nodes in a Binary Tree
  • An Implementation of the ADT Binary Tree
  • An Implementation of an Expression Tree
  • General Trees
  • Chapter Summary
  • Exercises
  • Projects

Lesson 25: A Binary Search Tree Implementation

  • Getting Started
  • Searching and Retrieving
  • Traversing
  • Adding an Entry
  • Removing an Entry
  • The Efficiency of Operations
  • An Implementation of the ADT Dictionary
  • Chapter Summary
  • Exercises
  • Projects

Lesson 26: A Heap Implementation

  • Reprise: The ADT Heap
  • Using an Array to Represent a Heap
  • Adding an Entry
  • Removing the Root
  • Creating a Heap
  • Heap Sort
  • Chapter Summary
  • Exercises
  • Projects

Lesson 27: Balanced Search Trees

  • AVL Trees
  • 2-3 Trees
  • 2-4 Trees
  • Red-Black Trees
  • B-Trees
  • Chapter Summary
  • Exercises
  • Projects

Lesson 28: Graphs

  • Some Examples and Terminology
  • Traversals
  • Topological Order
  • Paths
  • Java Interfaces for the ADT Graph
  • Chapter Summary
  • Exercises
  • Projects

Lesson 29: Graph Implementations

  • An Overview of Two Implementations
  • Vertices and Edges
  • An Implementation of the ADT Graph
  • Chapter Summary
  • Exercises
  • Projects

Lesson 30: Mutable, Immutable, and Cloneable Objects

  • Mutable and Immutable Objects
  • Cloneable Objects
  • Chapter Summary
  • Exercises
  • Projects

Copyright © 2002-2017 uCertify / All Rights Reserved.