Generic filters
Exact matches only
Search in title
Search in content
Search in excerpt

Data Structures and Abstractions with Java

Enroll Now
  • Price: $279.99
  • Delivery method: eLearning
  • DIR Discount: 20%

Submit form to obtain discount

Test Prep
146+ Pre Assessment Questions | 145+ Post Assessment Questions |
Features
Find More E-Learning Courses

Why choose TOPTALENT?

  • Get assistance every step of the way from our Texas-based team, ensuring your training experience is hassle-free and aligned with your goals.
  • Access an expansive range of over 3,000 training courses with a strong focus on Information Technology, Business Applications, and Leadership Development.
  • Have confidence in an exceptional 95% approval rating from our students, reflecting outstanding satisfaction with our course content, program support, and overall customer service.
  • Benefit from being taught by Professionally Certified Instructors with expertise in their fields and a strong commitment to making sure you learn and succeed.

Outline

Lessons 1:
Introduction 

  • Organizing Data

Lessons 2:
Prelude: Designing Classes

  • Encapsulation
  • Specifying Methods
  • Java Interfaces
  • Choosing Classes
  • Reusing Classes
  • Exercises
  • Projects

Lessons 3:
Bags

  • The Bag
  • Specifying a Bag
  • Using the ADT Bag
  • Using an ADT Is Like Using a Vending Machine
  • The ADT Set
  • Java Class Library: The Interface Set
  • Java Interlude 1: Generics
  • Lesson Summary
  • Programming Tip
  • Exercises
  • Projects

Lessons 4:
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
  • Java Interlude 2 Exceptions
  • Lesson Summary
  • Programming Tips
  • Exercises
  • Projects

Lessons 5:
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
  • Lesson Summary
  • Programming Tip
  • Exercises
  • Projects

Lessons 6:
The Efficiency of Algorithms

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

Lessons 7:
Stacks

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

Lessons 8:
Stack Implementations

  • A Linked Implementation
  • An Array-Based Implementation
  • A Vector-Based Implementation
  • Java Interlude 3: More About Exceptions
  • Lesson Summary
  • Exercises
  • Projects

Lessons 9:
Queues, Deques, and Priority Queues

  • The ADT Queue
  • The ADT Deque
  • The ADT Priority Queue
  • Lesson Summary
  • Programming Tip
  • Exercises
  • Projects

Lessons 10:
Queue, Deque, and Priority Queue Implementations

  • A Linked Implementation of a Queue
  • An Array-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
  • Lesson Summary
  • Programming Tip
  • Exercises
  • Projects

Lessons 11:
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
  • Tail Recursion
  • Using a Stack Instead of Recursion
  • Lesson Summary
  • Programming Tips
  • Exercises
  • Projects

Lessons 12:
Lists

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

Lessons 13:
A List Implementation That Uses an Array

  • Using an Array to Implement the ADT List
  • The Efficiency of Using an Array to Implement the ADT List
  • Lesson Summary
  • Exercises
  • Projects

Lessons 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
  • Java Interlude 4: Iterators
  • Lesson Summary
  • Exercises
  • Projects

Lessons 15:
Iterators for the ADT List

  • Ways to Implement an Iterator
  • A Separate Class Iterator
  • An Inner Class Iterator
  • Why Are Iterator Methods in Their Own Class?
  • An Array-Based Implementation of the Interface ListIterator
  • Lesson Summary
  • Programming Tip
  • Exercises
  • Projects

Lessons 16:
Problem Solving with Recursion

  • A Simple Solution to a Difficult Problem
  • A Poor Solution to a Simple Problem
  • Languages and Grammars
  • Indirect Recursion
  • Backtracking
  • Java Interlude 5: More About Generics
  • Lesson Summary
  • Exercises
  • Projects

Lessons 17:
An Introduction to Sorting

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

Lessons 18:
Faster Sorting Methods

  • Merge Sort
  • Quick Sort
  • Radix Sort
  • Comparing the Algorithms
  • Java Interlude 6: Mutable and Immutable Objects
  • Lesson Summary
  • Exercises
  • Projects

Lessons 19:
Sorted Lists

  • Specifications for the ADT Sorted List
  • A Linked Implementation
  • An Implementation That Uses the ADT List
  • Java Interlude 7: Inheritance and Polymorphism
  • Lesson Summary
  • Exercises
  • Projects

Lessons 20:
Inheritance and Lists

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

Lessons 21:
Searching

  • The Problem
  • Searching an Unsorted Array
  • Searching a Sorted Array
  • Searching an Unsorted Chain
  • Searching a Sorted Chain
  • Choosing a Search Method
  • Java Interlude 8: Generics Once Again
  • Lesson Summary
  • Programming Tip
  • Exercises
  • Projects

Lessons 22:
Dictionaries

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

Lessons 23:
Dictionary Implementations

  • Array-Based Implementations
  • Linked Implementations
  • Lesson Summary
  • Programming Tips
  • Exercises
  • Projects

Lessons 24:
Introducing Hashing

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

Lessons 25:
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
  • Lesson Summary
  • Exercises
  • Projects

Lessons 26:
Trees

  • Tree Concepts
  • Traversals of a Tree
  • Java
© 2024 TOPTALENT LEARNING.