Recursion, Algorithms and Data Structures Bootcamp in C++

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Chapter 2: ### RECURSION ###

Lecture 1: What are stack and heap memory?

Lecture 2: Stack memory and heap memory simulation

Lecture 3: What is recursion (recursive function call)?

Lecture 4: Head and tail recursion implementation

Lecture 5: Recursion and stack memory (stack overflow)

Lecture 6: Factorial problem – with head recursion and accumulator

Lecture 7: Factorial problem – visualizing the stack

Lecture 8: Fibonacci numbers problem – with head recursion

Lecture 9: Fibonacci numbers – visualizing the stack memory

Lecture 10: Fibonacci-numbers with tail recursion solution

Lecture 11: Towers of Hanoi introduction

Lecture 12: Towers of Hanoi implementation

Lecture 13: Towers of Hanoi – visualizing the stack

Lecture 14: Recursion and iteration (differences)

Chapter 3: ### SEARCH ALGORITHMS ###

Lecture 1: What is linear search?

Lecture 2: Linear search implementation

Lecture 3: What is binary (logarithmic) search?

Lecture 4: Binary search implementation

Chapter 4: ### BACKTRACKING ###

Lecture 1: What is backtracking?

Lecture 2: Brute-force search and backtracking

Lecture 3: N-queens problem introduction

Lecture 4: What is the search tree?

Lecture 5: N-queens problem implementation

Lecture 6: N-queens problem and the stack memory

Lecture 7: Coloring problem introduction

Lecture 8: Coloring problem visualization

Lecture 9: Coloring problem implementation

Lecture 10: Knight's tour problem introduction

Lecture 11: Knight's tour problem implementation

Lecture 12: What is the problem with backtracking?

Chapter 5: ### DYNAMIC PROGRAMMING ###

Lecture 1: What is dynamic programming?

Lecture 2: Fibonacci numbers introduction

Lecture 3: Fibonacci numbers implementation

Lecture 4: Knapsack problem introduction

Lecture 5: Knapsack problem example

Lecture 6: Knapsack problem implementation

Chapter 6: ### DATA STRUCTURES ###

Lecture 1: Why do we need data structures?

Lecture 2: Data structures and abstract data types

Chapter 7: Data Structures – Arrays

Lecture 1: What are array data structures?

Lecture 2: Arrays introduction – operations

Lecture 3: Arrays in C++

Chapter 8: Data Structures – Linked Lists

Lecture 1: What are linked lists?

Lecture 2: Linked list theory – operations

Lecture 3: Pros and cons of linked lists

Lecture 4: Linked list implementation

Lecture 5: Comparing linked lists and arrays

Lecture 6: Practical (real-world) applications of linked lists

Chapter 9: Data Structures – Stacks

Lecture 1: What are stacks?

Lecture 2: Stacks in memory management (stacks and heaps)

Lecture 3: Stack memory visualization

Lecture 4: Stacks implementation with arrays

Lecture 5: Stack implementation with linked lists

Chapter 10: Data Structures – Queues

Lecture 1: What are queues?

Lecture 2: Queue implementation with linked list

Chapter 11: Data Structures – Trees

Lecture 1: Binary search trees theory – basics

Lecture 2: Binary search trees theory – search, insert

Lecture 3: Binary search trees theory – delete

Lecture 4: Binary search trees theory – in-order traversal

Lecture 5: Binary search trees theory – running times

Lecture 6: Binary search tree implementation I

Lecture 7: Stack memory visualization – finding max (min) items

Lecture 8: Stack memory visualization – tree traversal

Lecture 9: Binary search tree implementation II

Lecture 10: Binary search tree implementation III

Lecture 11: Practical (real-world) applications of trees

Chapter 12: Priority Queues (Heaps)

Lecture 1: What are priority queues?

Lecture 2: Heap introduction – basics

Lecture 3: Heap introduction – array representation

Lecture 4: Heap introduction – remove operation

Lecture 5: Using heap data structure to sort (heapsort)

Lecture 6: Heap introduction – running times

Lecture 7: Binomial and Fibonacci heaps

Lecture 8: Heaps implementation I

Lecture 9: Heaps implementation II