NEW COURSE!

Data Structures and Algorithms

For a limited time, save 25% on this course

* This offer expires August 4, 2014 at 11:59pm PT and cannot be combined with any other discounts.

In this sixth course of our Java series you will work with the core data structures and algorithms needed to write efficient code. In many circumstances, the proper answer comes down to choosing the right data structure and implementing the right algorithm. Throughout the course, students are shown how to connect their growing knowledge of data structures with algorithms so they can design their own algorithms effectively. It will cover the core data structures in computer science including fixed arrays, linked lists, maps, queues and dequeues, trees and graphs, and will use existing implementations in the JDK to solve real problems.

Upon completion of this course, you will be able to:

  • Work effectively with the Java Collections Framework.
  • Analyze the performance of your algorithms.
  • Demonstrate mastery of core data structures, such as trees, graphs, maps, queues and dequeus.
  • Design complex data structures and algorithms based on these core data structures.

From beginning to end, you will learn by doing your own Java projects within our Eclipse Learning Sandbox, which we affectionately call “Ellipse.” The projects give students the opportunity to solve real-world problems using a variety of algorithms covered in the course. Throughout the course, students are shown how to connect their growing knowledge of data structures with algorithms so they can design their own algorithms effectively. Besides a browser and internet connection, all software is provided online by the O’Reilly School of Technology.

Prerequisites: Java 4: Java Application Building, or equivalent skills. This course is meant for the intermediate or advanced programmer. It is also recommended that students have a strong working knowledge of discrete mathematics and/or linear algebra.

135 Clock-hours

 $498.00   $373.50 (plus fees)

Enroll in Course

Course Details and Syllabus

Course: Data Structures and Algorithms
Tuition:  $498.00   $373.50 (plus fees)
Time Frame: This course is online and self-paced. You can expect to work approximately 135 hours on this course.
Technical Requirements: As long as you have a web browser and internet connection, you can take this course from anywhere.
Software: The Ellipse Learning Sandbox® provided for you will contain all your lessons, projects, quizzes, account files, editors, and compiling tools necessary to build your skills from beginning to end, even beyond coursework. No other software is needed.
Instructor: You will have one instructor throughout the course who will evaluate your projects and quizzes, hand them back for improvement when necessary, and coach you throughout your skills advancement.
Book: All required course materials and software are included online within the Learning Sandbox®. However, within a few weeks of enrolling, you’ll receive the e-book Algorithms in a Nutshell as a reference resource from O’Reilly.Algorithms in a Nutshell Cover
Certificates: This does course does not currently count towards a certificate.
Prerequisites: Java 4: Java Application Building, or equivalent skills. This course is meant for the intermediate or advanced programmer. It is also recommended that students have a strong working knowledge of discrete mathematics and/or linear algebra.
Topics:  Core data structures, fixed arrays, linked lists, maps, queues and dequeues, trees and graphs, and use of the JDK.
Syllabus:
  • Lesson 1: Data Structures and Algorithms Overview
    • Algorithm Performance
    • Constant Performance
    • Logarithmic Performance
    • Linear Perfomance
    • Quadratic Perfomance
    • Comparing Classification Families
    • ArrayList Amortized Reallocation
  • Lesson 2: Data Structures and the Java Collections Framework
    • Introduction to Java Collections Framework
    • Set Interface
    • List Interface
    • Queue Interface
    • Map Interface
    • Summarizing the Implementations You Need to Know
    • Important Methods For Keys and Values
  • Lesson 3: Algorithms Using Java
    • Designing Algorithms
    • Skyline Problem
  • Lesson 4: Working With Big Data
    • Sorting Large Sets Using External Storage
    • Characterizing Storage Requirements for an Algorithm
    • MergeSort with O(n) Storage Requirements
    • Working with Large Datasets
    • Never Be Satisfied
  • Lesson 5: Representing Graph Data Structures
    • Using Adacency Matric To Represent Graph
    • Searching a Graph
    • Practical Application
  • Lesson 6: Graph Adjacency Lists and Shortest Path Algorithms
    • Searching for Optimal Paths
    • Representing Graph by Adjacency List
    • Breadth-First Search
  • Lesson 7: Priority Queues
    • Priority Queue Data Structure
    • Minimum Spanning Tree
    • Heap Data Structure
    • Prim’s Algorithm Implementation
    • Evaluating Minimum Spanning Tree Implementations
  • Lesson 8: Binary Tree Data Structure
    • Naive Binary Tree Implementation
    • Evaluating Binary Tree Implementation
    • Rebalancing Binary Trees
    • Using Collections TreeSet
  • Lesson 9: Multidimensional Algorithms
    • A Data Structure for Multidimensional Algorithms
    • Traversing a kd-tree
    • Using kd-trees to Search for Points
  • Lesson 10: Mathematical Algorithms and Floating Point Computations
    • Gauss Jordan Elimination
    • Rounding Errors
    • Partial Input Data
    • Matrix Determinant
  • Lesson 11: Brute Force Algorithms
    • Using Brute Force to Solve Permutation Problems
    • Finding All Five-Letter Words in PALINDROME
    • N Queens Problem
  • Lesson 12: Path Finding for Single-Player Games
    • Breadth-First Search
    • Evaluating Search Tree Algorithms
  • Lesson 13: Path Finding for Two-Player Games
    • Minimax Implementation
  • Lesson 14: Algorithms On Sound Data
    • Composed Wave Forms
    • Analyzing Composed Wave Forms
    • Using FFT on WAV file samples
  • Lesson 15: Conclusion
    • Removing Elements From a Sorted Array
    • Removing Elements From a Binary options broker Search Trees
    • Removing Elements From AVL Trees
    • Removing Elements From KD-trees