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

Data Structures and Abstractions with Java

The Data Structures and Abstractions with Java course covers a wide range of topics related to data structures and algorithms, including arrays, linked lists, stacks, queues, trees, graphs, recursion, sorting, sets, and maps. It provides introduction to these concepts, starting with the basics and gradually building up to more advanced topics. The course covers the implementation of data structures using the Java programming language, with a focus on design decisions and safe and secure programming practices. The course also covers the topics, such as Java basics, file input and output and glossary, making the course a comprehensive resource for learners seeking to enhance their knowledge in data structures and Java programming.
  • Price: $279.99
  • Delivery Method: eLearning
NameBuy
Data Structures and Abstractions with Java
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