Data Structures

Data Structures


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 Quizzes

Each lesson comes with Exercises & Quizzes. 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.

Exercise Questions

Table of Content

Here's What you will Learn

Lesson 1: Abstract Data Types and Sequentially Allocated Bags

  • The Bag
  • Specifying a Bag
  • Using the ADT Bag
  • Using an ADT Is Like Using a Vending Machine
  • Bag Implementations That Use Arrays
  • Using a Fixed-Size Array to Implement the ADT Bag
  • The Pros and Cons of Using an Array to Implement the ADT Bag

Lesson 2: Implementing Bags with Linked Allocation

  • 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 3: Introduction to Analysis of Algorithms

  • The Efficiency of Algorithms
  • Motivation
  • Measuring an Algorithm's Efficiency
  • Picturing Efficiency
  • The Efficiency of Implementations of the ADT Bag

Lesson 4: Stacks

  • Stacks
  • Specifications of the ADT Stack
  • Using a Stack to Process Algebraic Expressions
  • Stack Implementations
  • A Linked Implementation
  • An Array-Based Implementation

Lesson 5: Queues

  • Queues, Deques, and Priority Queues
  • The ADT Queue
  • Queue, Deque, and Priority Queue Implementations
  • A Linked Implementation of a Queue
  • An Array-Based Implementation of a Queue

Lesson 6: Deques

  • The ADT Deque
  • A Doubly Linked Implementation of a Deque

Lesson 7: Lists

  • Lists
  • Specifications for the ADT List
  • Using the ADT List
  • List Implementations That Use Arrays
  • Using an Array to Implement the ADT List
  • 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

Lesson 8: Basic Sorting Algorithms

  • An Introduction to Sorting
  • Organizing Java Methods That Sort an Array
  • Selection Sort
  • Insertion Sort

Lesson 9: Faster Sorting Algorithms

  • Faster Sorting Methods
  • Merge Sort
  • Quick Sort
  • Radix Sort

Lesson 10: Sorted Lists

  • Specifications for the ADT Sorted List
  • A Linked Implementation

Lesson 11: Searching a List

  • Searching
  • The Problem
  • Searching an Unsorted Array
  • Searching a Sorted Array
  • Searching an Unsorted Chain
  • Searching a Sorted Chain
  • Choosing a Search Method

Lesson 12: Dictionary as an Associative ADT

  • Dictionaries
  • Specifications for the ADT Dictionary
  • Using the ADT Dictionary

Lesson 13: Sequential Hash Tables

  • Introducing Hashing
  • What Is Hashing?
  • Hash Functions
  • Resolving Collisions

Lesson 14: Bucket Hashing

Lesson 15: Introduction to Trees

  • Tree Concepts
  • Traversals of a Tree
  • Examples of Binary Trees
  • Examples of General Trees

Lesson 16: Implementation of Binary Trees

  • An Implementation of the ADT Binary Tree

Lesson 17: Binary Search Trees

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

Lesson 18: Appendix A Java Essentials

  • Introduction
  • Java Basics
  • 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

Lesson 19: Appendix B Java Classes

  • Objects and Classes
  • Using the Methods in a Java Class
  • Defining a Java Class
  • Enumeration as a Class
  • Packages
  • Generic Data Types

Lesson 20: Appendix C Creating Classes from Other Classes

  • Composition
  • Inheritance
  • Type Compatibility and Superclasses
  • Polymorphism

Lesson 21: Appendix D Designing Classes

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

Lesson 22: Appendix E Handling Exceptions

  • The Basics
  • Handling an Exception
  • Throwing an Exception
  • Programmer-Defined Exception Classes
  • Inheritance and Exceptions
  • The finally Block

Lesson 23: Appendix F File Input and Output

  • Preliminaries
  • Text Files
  • Binary Files

Lesson 24: Appendix G Documentation and Programming Style

  • Naming Variables and Classes
  • Indenting
  • Comments

Copyright © 2002-2017 uCertify / All Rights Reserved.