Data Structures and Abstractions with Java
(DS-JAVA.AP1)
/ ISBN: 978-1-64459-381-3
This course includes
Lessons
TestPrep
Lab
Mentoring (Add-on)
Data Structures and Abstractions with Java
Lessons
-
37+ Lessons
-
291+ Exercises
-
506+ Quizzes
-
523+ Flashcards
-
523+ Glossary of terms
TestPrep
-
146+ Pre Assessment Questions
-
145+ Post Assessment Questions
Lab
-
74+ Performance lab
- Organizing Data
- Encapsulation
- Specifying Methods
- Java Interfaces
- Choosing Classes
- Reusing Classes
- Exercises
- Projects
- 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
- 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
- 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
- Motivation
- Measuring an Algorithm’s Efficiency
- Big Oh Notation
- Picturing Efficiency
- The Efficiency of Implementations of the ADT Bag
- Lesson Summary
- Exercises
- Projects
- 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
- A Linked Implementation
- An Array-Based Implementation
- A Vector-Based Implementation
- Java Interlude 3: More About Exceptions
- Lesson Summary
- Exercises
- Projects
- The ADT Queue
- The ADT Deque
- The ADT Priority Queue
- Lesson Summary
- Programming Tip
- Exercises
- Projects
- 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
- 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
- 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
- Using an Array to Implement the ADT List
- The Efficiency of Using an Array to Implement the ADT List
- Lesson Summary
- Exercises
- Projects
- 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
- 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
- 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
- Organizing Java Methods That Sort an Array
- Selection Sort
- Insertion Sort
- Shell Sort
- Comparing the Algorithms
- Lesson Summary
- Programming Tip
- Exercises
- Projects
- Merge Sort
- Quick Sort
- Radix Sort
- Comparing the Algorithms
- Java Interlude 6: Mutable and Immutable Objects
- Lesson Summary
- Exercises
- Projects
- 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
- Using Inheritance to Implement a Sorted List
- Designing a Base Class
- An Efficient Implementation of a Sorted List
- Lesson Summary
- Programming Tips
- Exercises
- Projects
- 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
- Specifications for the ADT Dictionary
- Using the ADT Dictionary
- Java Class Library: The Interface Map
- Lesson Summary
- Programming Tips
- Exercises
- Projects
- Array-Based Implementations
- Linked Implementations
- Lesson Summary
- Programming Tips
- Exercises
- Projects
- What Is Hashing?
- Hash Functions
- Resolving Collisions
- Lesson Summary
- Exercises
- Projects
- 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
- Tree Concepts
- Traversals of a Tree
- Java Interfaces for Trees
- Examples of Binary Trees
- Examples of General Trees
- Lesson Summary
- Exercises
- Projects
- The Nodes in a Binary Tree
- An Implementation of the ADT Binary Tree
- An Implementation of an Expression Tree
- General Trees
- Using a Binary Tree to Represent a General Tree
- Java Interlude 9: Cloning
- Lesson Summary
- Programming Tips
- Exercises
- Projects
- Getting Started
- Searching and Retrieving
- Traversing
- Adding an Entry
- Removing an Entry
- The Efficiency of Operations
- An Implementation of the ADT Dictionary
- Lesson Summary
- Exercises
- Projects
- Reprise: The ADT Heap
- Using an Array to Represent a Heap
- Adding an Entry
- Removing the Root
- Creating a Heap
- Heap Sort
- Lesson Summary
- Exercises
- Projects
- AVL Trees
- 2-3 Trees
- 2-4 Trees
- Red-Black Trees
- B-Trees
- Lesson Summary
- Exercises
- Projects
- Some Examples and Terminology
- Traversals
- Topological Order
- Paths
- Java Interfaces for the ADT Graph
- Lesson Summary
- Exercises
- Projects
- An Overview of Two Implementations
- Vertices and Edges
- An Implementation of the ADT Graph
- Lesson Summary
- Exercises
- Projects
- Naming Variables and Classes
- Indenting
- Comments
- Objects and Classes
- Using the Methods in a Java Class
- Defining a Java Class
- Enumeration as a Class
- Packages
- Composition
- Inheritance
- Type Compatibility and Superclasses
- Introduction
- Elements of Java
- Simple Input and Output Using the Keyboard and Screen
- The if-else Statement
- The switch Statement
- Enumerations
- Scope
- Loops
- The Class String
- The Class StringBuilder
- Using Scanner to Extract Pieces of a String
- Arrays
- Wrapper Classes
- Preliminaries
- Text Files
- Binary Files
Hands on Activities (Performance Labs)
- Counting the Occurrence of Each Item in a Bag
- Performing Matrix Multiplication
- Transposing a Matrix
- Finding the Intersection of Two Arrays
- Handling an Exception
- Counting the Entries in a Bag
- Adding a Node at the End of a Doubly Linked Chain
- Removing First Node from a Doubly Linked Chain
- Adding Nodes to the Beginning of a Doubly Linked Chain
- Searching an Entry in a Bag
- Rearranging the Integers in an Array
- Creating a Stack and Adding Five Elements to it
- Removing an Element from a Stack
- Searching an Element in a Stack
- Transferring the Elements of One Stack to Another
- Transforming an Infix Expression to a Postfix Expression
- Evaluating a Postfix Expression
- Evaluating an Infix Expression
- Testing an Input String for Palindrome Using a Stack
- Creating an Array-Based Stack to Retrieve the Topmost Entry
- Creating a Vector-Based Stack to Retrieve the Topmost Entry
- Creating Custom Exception Class
- Creating a Queue
- Creating a Deque
- Creating a Priority Queue
- Removing the First Element from a Circular Linked Queue
- Removing the First Element from a Doubly Linked Deque
- Creating a Recursive Void Method to Print First Five Natural Numbers
- Traversing the Elements of a Linked List in Reverse Order
- Creating a Recursive Method to Return the Factorial of a Number
- Replacing an Element in the Linked List
- Removing an Element from the Specified Position in a Linked List
- Locating an Element in the Linked List
- Adding an Element at the Specified Position in a Linked List
- Converting an ArrayList to an Array
- Working with a List
- Traversing a List
- Removing Duplicates from the List
- Evaluating a Prefix Expression
- Sorting an Array using Selection Sort
- Sorting an Array using Insertion Sort
- Sorting an Array using Shell Sort
- Sorting an Array using Merge Sort
- Sorting an Array using Quick Sort
- Sorting an Array using Radix Sort
- Replacing a Word Using the StringBuilder Class
- Inserting an Element into a Sorted Array
- Using Polymorphism
- Using the Abstract Class
- Sorting a List using Inheritance
- Performing Sequential Search
- Performing Binary Search
- Implementing a Dictionary
- Implementing a Map
- Searching for a Key in a Dictionary
- Using Linear Probing in a Hash Table
- Implementing HashMap
- Traversing a Binary Tree using Inorder Traversal
- Traversing a Binary Tree using Preorder Traversal
- Traversing a Binary Tree Using Postorder Traversal
- Counting the Nodes of a Binary Tree
- Computing the Height of a Binary Tree
- Searching a Node in the Binary Search Tree
- Removing a Node from a Binary Search Tree
- Adding Nodes to a Max Heap
- Removing the Maximum Value Node from a Max Heap
- Sorting an Array using Heap Sort
- Adding Nodes to an AVL Tree
- Using the DFS Traversal
- Using the BFS Traversal
- Using Topological Sort
- Using Dijkstra's Algorithm
- Printing an Adjacency List
- Printing an Adjacency Matrix
×
