Data Structures and Algorithms Python: The Complete Bootcamp

Course Curriculum

Chapter 1: Course Introduction

Lecture 1: Course Introduction

Lecture 2: Welcome – Lets Get Started!

Lecture 3: Curriculum Walkthrough

Lecture 4: Code Source – Github

Chapter 2: Big O Notation

Lecture 1: Section Introduction

Lecture 2: Complexity Analysis

Lecture 3: Why we need Big O Notation?

Lecture 4: Big O(n) Complexity

Lecture 5: Big O(1) Complexity

Lecture 6: Counting Operations

Lecture 7: Simplifying Big O – Part 1

Lecture 8: Big O(n^2) Complexity

Lecture 9: Simplifying Big O – Part 2

Lecture 10: Big O(n!) Complexity

Lecture 11: Space Complexity

Lecture 12: Space Complexity – II

Lecture 13: Section Summary

Chapter 3: Essential Concepts – I

Lecture 1: Memory

Lecture 2: Logarithm

Chapter 4: Data Structure – Introduction

Lecture 1: Introduction to Data Structures

Chapter 5: Data Structures – Array

Lecture 1: Array Introduction

Lecture 2: Array – Common Operations I

Lecture 3: Array – Common Operations II

Lecture 4: Static vs Dynamic Array – Common Operations III

Chapter 6: Data Structures – Linked List

Lecture 1: Linked List

Lecture 2: Linked List Complexities

Lecture 3: Doubly Linked List

Lecture 4: Circular Linked List and Implementing A Linked List

Chapter 7: Data Structures – Stack and Queue

Lecture 1: Stack and Queue

Chapter 8: Data Structures – Hash Tables

Lecture 1: Hash Tables

Chapter 9: Data Structures – Trees

Lecture 1: Tree – Part 1

Lecture 2: Tree – Part 2

Lecture 3: Binary Tree

Lecture 4: Types Of Binary Tree

Lecture 5: Binary Search Tree

Lecture 6: AVL – Red Back Tree

Chapter 10: Data Structures – Heaps

Lecture 1: Heaps

Lecture 2: Heap Sort and Priority Queue

Chapter 11: Data Structures – Trie

Lecture 1: Trie – I

Lecture 2: Trie – II

Lecture 3: Why are Tries Important?

Chapter 12: Data Structures – Graph

Lecture 1: Graph

Chapter 13: Essential Concepts – II

Lecture 1: What is Recursion?

Lecture 2: Recursion: Control of a Function

Lecture 3: Recursion: Tracing Tree

Lecture 4: Recursion: Understanding Call Stack

Lecture 5: Recursion: Tree Recursion

Lecture 6: Recursion Example – Factorial of a Number

Chapter 14: Algorithm: Searching

Lecture 1: Linear Search

Lecture 2: Binary Search

Lecture 3: Binary Search Complexity

Lecture 4: Binary Search Implementation

Lecture 5: Binary Search Implementation – Recursion

Chapter 15: Algorithm: Sorting Elementary

Lecture 1: Sorting Algorithm Introduction

Lecture 2: Bubble Sort

Lecture 3: Bubble Sort Visualization

Lecture 4: Bubble Sort Implementation

Lecture 5: Bubble Sort Complexity

Lecture 6: Selection Sort

Lecture 7: Selection Sort Visualization

Lecture 8: Selection Sort – Implementation

Lecture 9: Selection Sort – Complexity

Lecture 10: Insertion Sort

Lecture 11: Insertion Sort Implementation

Lecture 12: Insertion Sort Complexity

Lecture 13: Performance Analysis

Chapter 16: Algorithm: Sorting Advanced

Lecture 1: Divide and Conquer Algorithms

Lecture 2: Quick Sort

Lecture 3: Quick Sort Complexity

Lecture 4: Quick Sort Implementation

Lecture 5: Merge Sort

Lecture 6: Merge Sort Complexity

Lecture 7: Merge Sort Implementation

Chapter 17: Algorithms: Tree Traversal

Lecture 1: Tree Traversal

Lecture 2: Depth First Search – Preorder Inorder Postorder

Lecture 3: Binary Tree Implementation

Lecture 4: Depth First Search – Implementation

Lecture 5: Depth First Search – Complexity

Lecture 6: Breadth First Search – Level Order

Lecture 7: Breadth First Search – Implementation

Lecture 8: Breadth First Search – Complexity

Chapter 18: Algorithms: Graph Traversal

Lecture 1: Graph Traversal