code Data Structures Training Course

Data Structures Training Course

Learn the fundamentals of Data Structures, and how to apply your knowledge


  • 5 Days

What do I need?

  • Webinar : A laptop, and a stable internet connection. The recommended minimum speed is around 10 Mbps.
  • Classroom Training : A laptop, please notify us if you are not bringing your own laptop. Please see the calendar below for the schedule


  • Attendance : If you have attended 80% of the sessions and completed all the class work, you qualify for the Attendance Certificate. (Course Price : R14 995)
  • Competency : If you have also enrolled for the additional competency projects, you qualify for the Competency Certificate. (Course Price : R18 995)


What you will learn

  • How to work hands-on with a variety of storage mechanisms, including linked lists,stacks, queues and graphs, within the constraints of the JavaScript Environment
  • You will learn to determine which data structures and algorithms are most appropriate for the problems you're trying to solve
  • You will understand the tradeoffs when using them in a JavScript program


The JavaScript Programming Environment and Model

  • The JavaScript Environment
  • JavaScript Programming Practices
    • Declaring and Intializing Variables
    • Arithmetic and Math Library Functions in JavaScript
    • Decision Constructs
    • Repetition Constructs
    • Functions
    • Variable Scope
    • Recursion
  • Objects and Object-Oriented Programming
  • Arrays

  • JavaScript Arrays Defined
  • Using Arrays
    • Creating Arrays
    • Accessing and Writing Array Elements
    • Creating Arrays from Strings
    • Aggregate Array Operations
  • Accessor Functions
    • Searching for a Value
    • String Representations of Arrays
    • Creating New Arrays from Existing Arrays
  • Mutator Functions
    • Adding Elements to an Array
    • Removing Elements from an Array
    • Adding and Removing Elements from the Middle of an Array
    • Putting Array Elements in Order
  • Iterator Functions
    • Non–Array-Generating Iterator Functions
    • Iterator Functions That Return a New Array
  • Two-Dimensional and Multidimensional Arrays
    • Creating Two-Dimensional Arrays
    • Processing Two-Dimensional Array Elements
    • Jagged Arrays
  • Arrays of Object
  • Arrays in Objects
  • Lists

  • A List ADT
  • A List Class Implementation
    • Append: Adding an Element to a List
    • Remove: Removing an Element from a List
    • Find: Finding an Element in a List
    • Length: Determining the Number of Elements in a List
    • toString: Retrieving a List’s Elements
    • Insert: Inserting an Element into a List
    • Clear: Removing All Elements from a List
    • Contains: Determining if a Given Value Is in a List
    • Traversing a List
  • Iterating Through a List
  • A List-Based Application
    • Reading Text Files
    • Using Lists to Manage a Kiosk

Day Two


  • Stack Operations
  • A Stack Implementation
  • Using the Stack Class
    • Multiple Base Conversions
    • Palindromes
    • Demonstrating Recursion


  • Queue Operations
  • An Array-Based Queue Class Implementation
  • Using the Queue Class: Assigning Partners at a Square Dance
  • Sorting Data with Queues
  • Priority Queues
  • Linked Lists

  • Shortcoming of Arrays
  • Linked Lists Defined
  • An Object-Based Linked List Design
    • The Node Class
    • The Linked List Class
    • Inserting new Nodes
    • Removing Nodes from a Linked List
  • Doubly Linked Lists
  • Circularly Linked Lists
  • Other linked list functions
  • Day Three


  • The Dictionary Class
  • Auxilliary Functions for the Dictionary Class
  • Adding sorting to the Dictionary Class
  • Hashing

  • An Overview of Hashing
  • A Hash Table Class
    • Choosing a Hash Function
    • A Better Hash Function
    • Hashing Integer Keys
    • Storing and Retrieving Data in a Hash Table
  • Handling Collisions
    • Separate Chaining
    • Linear Probing


  • Fundamental Set Definitions, Operations, and Properties
    • Set Definitions
    • Set Operations
  • The Set Class Implementation
  • Day Four

    Binary Trees and Binary Search Trees

  • Trees Defined
  • Binary Trees and Binary Search Trees
    • Building a Binary Search Tree Implementation
    • Traversing a Binary Search Tree
  • BST Searches
    • Searching for the Minimum and Maximum Value
    • Searching for a Specific Value
  • Removing Nodes from a BST
  • Counting Occurences
  • Graphs and Graph Algorithms

  • Graph Definitions
  • Real-World Systems Modeled by Graphs
  • The Graph Class
    • Representing Vertices
    • Representing Edges
    • Building a Graph
  • Searching a Graph
    • Depth-First Search
    • Breadth-First Search
  • Finding the Shortest Path
    • Breadth-First Search Leads to Shortest paths
    • Determining Paths
  • Topological Sorting
    • An Algorithm for topological Sorting
    • Implementing the Topological Sorting Algorithm

    Sorting Algorithms

  • An Array Test Bed
    • Generating Random Data
  • Basic Sorting Algorithms
    • Bubble Sort
    • Selection Sort
    • Insertion Sort
    • Timing Comparisons of the Basic Sorting Algorithms
  • Advanced Sorting Algorithms
    • The Shellsort Algorithm
    • The Mergesort Algorithm
    • The Quicksort Algorithm

    Day Five

    Searching Algorithms

  • Sequential Search
    • Searching for Minimum and Maximum Values
    • Using Self-Organizing Data
  • Binary Search
  • Counting Occurences
    • Searching Textual Data

    Advanced Algorithms

  • Dynamic Programming
    • A Dynamic Programming Example: Computing Fibonacci Numbers
    • Finding the Longest Common Substring
    • The Knapsack Problem: A Recursive Solution
    • The Knapsack Problem: A Dynamic Programming Solution
  • Greedy Algorithms
    • A First Greedy Algorithm Example: The Coin-Changing Problem
    • A Greedy Algorithm Solution to the Knapsack Problem

    Subscribe to our Newsletter for latest news.

    If the pdf download does not work, try a different browser

    Save as PDF
    © 2004+
    Back to top