Mastering Data Structures & Algorithms using C and C++

Course Curriculum

Chapter 1: Before we Start

Lecture 1: Instructor's Note

Lecture 2: Introduction

Chapter 2: Essential C and C++ Concepts

Lecture 1: Arrays Basics

Lecture 2: Practice : Arrays Basics

Lecture 3: Structures

Lecture 4: Practice : Structures

Lecture 5: Pointers

Lecture 6: Practice : Pointers

Lecture 7: Reference in C++

Lecture 8: Practice : Reference

Lecture 9: Pointer to Structure

Lecture 10: Practice : Pointer to Structure

Lecture 11: Functions

Lecture 12: Practice : Functions

Lecture 13: Parameter Passing Methods

Lecture 14: Practice : Parameter Passing Methods

Lecture 15: Array as Parameter

Lecture 16: Practice : Array as Parameter

Lecture 17: Structure as Parameter

Lecture 18: Practice : Structure as Parameter

Lecture 19: Structures and Functions (Must Watch)

Lecture 20: Converting a C program to a C++ class (Must Watch)

Lecture 21: Practice : Monolithic Program

Lecture 22: Practice : Modular Program

Lecture 23: Practice : Structure and Functions

Lecture 24: Practice : Object-Oriented Program

Lecture 25: C++ Class and Constructor

Lecture 26: Practice : C++ Class

Lecture 27: Template classes

Lecture 28: Practice : Template Class

Chapter 3: Required Setup for Programming

Lecture 1: Online C and C++ compiler

Lecture 2: Setup CodeBlocks and Settings

Lecture 3: Setup Dev-C++ and Settings

Lecture 4: Debugging using Dev-C++

Lecture 5: Debugging using CodeBlocks

Lecture 6: Setup Visual Studio

Lecture 7: Debugging using Visual Studio

Lecture 8: Setup Xcode

Chapter 4: Introduction

Lecture 1: Introduction

Lecture 2: Stack vs Heap Memory

Lecture 3: Stack vs Heap. Continued…

Lecture 4: Physical vs Logical Data Structures

Lecture 5: ADT

Lecture 6: Time and Space Complexity

Lecture 7: Time and Space Complexity from Code

Chapter 5: Recursion

Lecture 1: How Recursion Works ( Tracing )

Lecture 2: Generalising Recursion

Lecture 3: How Recursion uses Stack

Lecture 4: Recurrence Relation – Time Complexity of Recursion

Lecture 5: Lets Code Recursion

Lecture 6: Static and Global Variables in Recursion

Lecture 7: Let's Code Static and Global in Recursion

Lecture 8: Tail Recursion

Lecture 9: Head Recursion

Lecture 10: Tree Recursion

Lecture 11: Let's Code Tree Recursion

Lecture 12: Indirect Recursion

Lecture 13: Let's Code Indirect Recursion

Lecture 14: Nested Recursion

Lecture 15: Let's Code Nested Recursion

Lecture 16: Sum of Natural Number using Recursion

Lecture 17: Let's Code Sum of N using Recursion

Lecture 18: Factorial using Recursion

Lecture 19: Let's Code Factorial using Recursion

Lecture 20: Power using Recursion

Lecture 21: Let's Code Power Recursion

Lecture 22: Taylor Series using Recursion

Lecture 23: Let's Code Taylor Series using Recursion

Lecture 24: Taylor Series using Horner's Rule

Lecture 25: Let's Code Taylor Series Horner's Rule – Recursion

Lecture 26: Let's Code Taylor Series Iterative

Lecture 27: Fibonacci Series using Recursion – Memoization

Lecture 28: Let's Code Fibonacci

Lecture 29: nCr using Recursion

Lecture 30: Let's Code nCr using Recursion

Lecture 31: Tower of Hanoi Problem

Lecture 32: Let's Code Tower of Hanoi

Lecture 33: Quiz 1 Solutions

Chapter 6: Arrays Representations

Lecture 1: Introduction to Array

Lecture 2: Declarations of Array

Lecture 3: Demo – Array Declaration

Lecture 4: Static vs Dynamic Arrays

Lecture 5: Demo – Static vs Dynamic Array

Lecture 6: How to Increase Array Size

Lecture 7: Demo – Increasing Array Size

Lecture 8: 2D Arrays

Lecture 9: Demo – 2D Array

Lecture 10: Array Representation by Compiler

Lecture 11: Row Major Formula for 2D Arrays

Lecture 12: Column Major Formula for 2D Arrays

Lecture 13: Formulas for nD Arrays

Lecture 14: Formulas for 3D Arrays