Introduction to Data Structures & Algorithms in Java

Course Curriculum

Chapter 1: Introduction to Algorithms

Lecture 1: Introduction

Lecture 2: Euclid's algorithm

Lecture 3: Bubble Sort algorithm

Lecture 4: Why study data structures & algorithms

Lecture 5: Correctness of an algorithm

Chapter 2: Analysis of Algorithms

Lecture 1: Note on this section

Lecture 2: Introduction

Lecture 3: How to calculate the time complexity

Lecture 4: The RAM model of computation

Lecture 5: Time complexity of Bubble sort algorithm

Lecture 6: Pseudo code : Bubble sort algorithm

Lecture 7: The Big O notation

Lecture 8: Using Big O notation : Examples

Lecture 9: Comparison of running times

Chapter 3: Basic Sorting and Search Algorithms

Lecture 1: Selection Sort

Lecture 2: Selection Sort : Pseudocode

Lecture 3: Introduction to Insertion Sort

Lecture 4: Applying Insertion Sort algorithm to cue balls

Lecture 5: Insertion Sort: Pseudocode

Lecture 6: O(n²) sorting algorithms – Comparison

Lecture 7: In place sorting

Lecture 8: Stable Vs Unstable Sorts

Lecture 9: Searching elements in an un ordered array

Lecture 10: Searching elements in an ORDERED array

Lecture 11: Searching elements in an ORDERED array – contd.

Lecture 12: Inserting and Deleting items in an ORDERED array

Lecture 13: Sorting any type of object

Lecture 14: Assignment

Chapter 4: Linked Lists

Lecture 1: What is a Linked List?

Lecture 2: Implementing a Linked List in Java

Lecture 3: Inserting a new Node

Lecture 4: Length of a Linked List

Lecture 5: Deleting the head node

Lecture 6: Searching for an Item

Lecture 7: Using java generics to parameterize the LinkedList

Lecture 8: Doubly Ended Lists

Lecture 9: Inserting data in a sorted Linked List

Lecture 10: Doubly Linked List

Lecture 11: Insertion Sort revisited

Lecture 12: Assignment

Chapter 5: Stacks and Queues

Lecture 1: Stacks

Lecture 2: Abstract Data Types

Lecture 3: Implementing Stacks using Arrays

Lecture 4: Queues

Lecture 5: Queues using Arrays

Lecture 6: Double Ended Queues

Lecture 7: Double Ended Queues using Arrays

Lecture 8: Assignment

Chapter 6: Recursion

Lecture 1: Introduction

Lecture 2: Understanding Recursion

Lecture 3: Tail recursion

Lecture 4: Tower of Hanoi

Lecture 5: Tower of Hanoi – Implementation

Lecture 6: Merge Sort

Lecture 7: Merge Sort – Pseudocode

Lecture 8: Merge Step – Pseudocode

Lecture 9: Time Complexity of Merge Sort

Lecture 10: Assignment

Chapter 7: Binary Search Trees

Lecture 1: The Tree Data structure

Lecture 2: Binary Trees

Lecture 3: Binary Search Trees

Lecture 4: Finding an item in a Binary Search Tree

Lecture 5: Implementing the find method

Lecture 6: Inserting an item in a Binary Search Tree

Lecture 7: Deleting an Item : Case 1

Lecture 8: Deleting an Item – Case 2

Lecture 9: Deleting an Item – Case 3

Lecture 10: Deleting an Item – Soft Delete

Lecture 11: Finding smallest & largest values

Lecture 12: Tree Traversal : In Order

Lecture 13: Tree Traversal : Pre Order

Lecture 14: Tree Traversal : Post Order

Lecture 15: Unbalanced Trees Vs Balanced Trees

Lecture 16: Height of a Binary Tree

Lecture 17: Time Complexity of Operations on Binary Search Trees

Lecture 18: Assignment

Chapter 8: More Sorting Algorithms

Lecture 1: Introduction

Lecture 2: QuickSort

Lecture 3: QuickSort: The partition step

Lecture 4: Shell Sort

Lecture 5: Shell Sort: Example

Lecture 6: Counting Sort

Lecture 7: Radix Sort

Lecture 8: Bucket Sort