Java Data Structures & Algorithms: Ace Coding Interviews!

Course Curriculum

Chapter 1: Introduction

Lecture 1: Why Should You Learn Data Structures and Algorithms ?

Lecture 2: What are Data Structures ?

Lecture 3: What are Algorithms ?

Chapter 2: Big O Notation

Lecture 1: Introduction to Big O Notation

Lecture 2: Linear Complexity – O(n)

Lecture 3: Constant Complexity – O(1)

Lecture 4: Quadratic Complexity – O(n^2)

Lecture 5: Logarithmic Complexity – O(logn)

Lecture 6: Constants in Big O

Lecture 7: Dominant and Non-Dominant Factors in Big O

Lecture 8: Complexities Comparison

Chapter 3: Big O Notation: Practical

Chapter 4: Linked Lists

Lecture 1: Introduction to Linked Lists

Lecture 2: Linked List Class Implementation

Lecture 3: Linked List: Add Element

Lecture 4: Linked List: Append Implementation

Lecture 5: Linked List: Prepend Implementation

Lecture 6: Linked List: Iterating

Lecture 7: Linked List: Iterating Implementation

Lecture 8: Linked List: Removing Elements

Lecture 9: Linked List: Removing Elements Implementation

Lecture 10: Time Complexity of Linked Lists Operations

Lecture 11: When to Use Linked Lists

Lecture 12: Linked List Use Case: Shopping Cart

Lecture 13: Java Built-In LinkedList Class

Chapter 5: Linked Lists: Practical

Lecture 1: (Video Solution) Music Playlist

Lecture 2: (Video Solution) Leetcode Challenge – Reverse Linked List

Chapter 6: Doubly Linked Lists

Lecture 1: Introduction to Doubly Linked Lists

Lecture 2: Doubly Linked List Class Implementation

Lecture 3: Doubly Linked List: Append Implementation

Lecture 4: Doubly Linked List: Prepend Implementation

Lecture 5: Doubly Linked List: Delete Implementation

Lecture 6: Doubly Linked List: Print Implementation

Lecture 7: Time Complexity of Doubly Linked Lists Operations

Lecture 8: Doubly Linked List Use Case: Text Cursor

Chapter 7: Doubly Linked Lists: Practical

Chapter 8: Stacks

Lecture 1: Introduction to Stacks

Lecture 2: Stack Implementation: Stack and Node Classes

Lecture 3: Stack Implementation: Push

Lecture 4: Stack Implementation: Pop & isEmpty

Lecture 5: Stack Use Case: Text Editor Undo Functionality

Lecture 6: Java Built-In Stack Class

Chapter 9: Stacks: Practical

Lecture 1: (Solution) Leetcode Challenge – Valid Parentheses

Chapter 10: Queues

Lecture 1: Introduction to Queues

Lecture 2: Queue Implementation: Queue and Node Classes

Lecture 3: Queue Implementation: Enqueue

Lecture 4: Queue Imeplementation: Dequeue

Lecture 5: Queue Use Case: Print Service

Lecture 6: Queue Interface in Java

Chapter 11: Queues: Practical

Lecture 1: (Solution) Leetcode Challenge – Implement Queue using Stacks

Chapter 12: Sets

Lecture 1: Introduction to Sets

Lecture 2: Creating and Initializing Sets

Lecture 3: Set's Methods and Operations

Lecture 4: Sets Big O

Lecture 5: Set Use Case: School Database

Chapter 13: Sets Practical

Chapter 14: Trees

Lecture 1: Introduction to Trees

Lecture 2: Binary Trees

Lecture 3: Complete Binary Trees

Lecture 4: Binary Search Trees

Lecture 5: Binary Search Trees: Insert Operation

Lecture 6: Binary Search Trees: Class Implementation

Lecture 7: Binary Search Trees: Insert Operation Implementation

Lecture 8: Binary Search Trees: Search Operation Implementation

Chapter 15: Trees: Practical

Lecture 1: (Solution) Leetcode Challenge – Search in a Binary Search Tree

Chapter 16: Heaps

Lecture 1: Introduction to Heaps

Lecture 2: Heaps: Insert

Lecture 3: Heaps: Pop

Lecture 4: Heap Implementation: Class and Helper Functions

Lecture 5: Heap Implementation: insert()

Lecture 6: Heap Implementation: remove()

Lecture 7: Heap Implementation: Heapify Down