Python 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

Chapter 5: Linked Lists: Practical

Lecture 1: Leetcode Challenge – Reverse Linked List: Solution

Lecture 2: Leetcode Challenge – Middle of the Linked List: Solution

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: Time Complexity of Doubly Linked Lists Operations

Lecture 7: 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: Python Built-In List as Stack

Lecture 6: Stack Use Case: Text Editor Undo Functionality

Chapter 9: Stacks: Practical

Lecture 1: Leetcode Challenge – Valid Parentheses: Solution

Chapter 10: Queues

Lecture 1: Introduction to Queues

Lecture 2: Queue Implementation: Queue and Node Classes

Lecture 3: Queue Implementation: isEmpty

Lecture 4: Queue Implementation: Enqueue

Lecture 5: Queue Imeplementation: Dequeue

Lecture 6: Queue Use Case: Print Service

Chapter 11: Queues: Practical

Lecture 1: Leetcode Challenge – Implement Queue Using Two Stacks: Solution

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: Unique Words Count

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: Leetcode Challenge – Search in a Binary Search Tree: Solution

Chapter 16: Heaps

Lecture 1: Introduction to Heaps

Lecture 2: Heaps: Insert

Lecture 3: Heaps: Pop

Lecture 4: Heap Implementation

Lecture 5: Heap Implementation: Insert & Heapify Up

Lecture 6: Heap Implementation: Pop

Lecture 7: Heap Implementation: Heapify Down

Lecture 8: Using heapq as Minimum Heap in Python

Lecture 9: Heap Operations Time Complexities