Mastering Data Structures & Algorithms using C and C++

Learn, Analyse and Implement Data Structure using C and C++. Learn Recursion and Sorting. Mastering Data Structures & Algorithms using C and C++.

You will Learn

  1. Before we Start (2 lectures) (15:44)
    • Instructor’s Note (02:22)
    • Introduction (13:22)
  2. Essential C and C++ Concepts (28 lectures) (04:15:35)
    • Arrays Basics (06:23)
    • Practice : Arrays Basics (13:37)
    • Structures (18:26)
    • Practice : Structures (10:49)
    • Pointers (11:01)
    • Practice : Pointers (14:41)
    • Reference in C++ (03:56)
    • Practice : Reference (05:15)
    • Pointer to Structure (06:03)
    • Practice : Pointer to Structure (06:44)
    • Functions (12:19)
    • Practice : Functions (05:37)
    • Parameter Passing Methods (14:03)
    • Practice : Parameter Passing Methods (11:20)
    • Array as Parameter (07:27)
    • Practice : Array as Parameter (13:36)
    • Structure as Parameter (10:32)
    • Practice : Structure as Parameter (11:05)
    • Structures and Functions (Must Watch) (05:15)
    • Converting a C program to a C++ class (Must Watch) (09:28)
    • Practice : Monolithic Program (04:50)
    • Practice : Modular Program (05:10)
    • Practice : Structure and Functions (05:09)
    • Practice : Object-Oriented Program (06:16)
    • C++ Class and Constructor (09:52)
    • Practice : C++ Class (05:35)
    • Template classes (10:49)
    • Practice : Template Class (10:17)
  3. Required Setup for Programming (8 lectures) (50:29)
    • Online C and C++ compiler (04:12)
    • Setup CodeBlocks and Settings (08:50)
    • Setup Dev-C++ and Settings (05:50)
    • Debugging using Dev-C++ (07:19)
    • Debugging using CodeBlocks (06:15)
    • Setup Visual Studio (06:09)
    • Debugging using Visual Studio (06:02)
    • Setup Xcode (05:52)
  4. Introduction (7 lectures) (01:24:42)
    • Introduction (13:28)
    • Stack vs Heap Memory (08:59)
    • Stack vs Heap. Continued… (13:07)
    • Physical vs Logical Data Structures (07:16)
    • ADT (14:30)
    • Time and Space Complexity (18:19)
    • Time and Space Complexity from Code (09:03)
  5. Recursion (33 lectures) (05:05:28)
    • How Recursion Works ( Tracing ) (19:04)
    • Generalising Recursion (02:07)
    • How Recursion uses Stack (10:48)
    • Recurrence Relation – Time Complexity of Recursion (11:07)
    • Lets Code Recursion (11:33)
    • Static and Global Variables in Recursion (08:29)
    • Let’s Code Static and Global in Recursion (07:01)
    • Tail Recursion (07:21)
    • Head Recursion (04:55)
    • Tree Recursion (17:27)
    • Let’s Code Tree Recursion (05:36)
    • Indirect Recursion (04:38)
    • Let’s Code Indirect Recursion (03:10)
    • Nested Recursion (07:05)
    • Let’s Code Nested Recursion (02:29)
    • Sum of Natural Number using Recursion (10:21)
    • Let’s Code Sum of N using Recursion (04:29)
    • Factorial using Recursion (04:40)
    • Let’s Code Factorial using Recursion (04:58)
    • Power using Recursion (13:40)
    • Let’s Code Power Recursion (03:29)
    • Taylor Series using Recursion (14:18)
    • Let’s Code Taylor Series using Recursion (03:51)
    • Taylor Series using Horner’s Rule (10:58)
    • Let’s Code Taylor Series Horner’s Rule – Recursion (02:09)
    • Let’s Code Taylor Series Iterative (02:02)
    • Fibonacci Series using Recursion – Memoization (19:33)
    • Let’s Code Fibonacci (12:56)
    • nCr using Recursion (09:24)
    • Let’s Code nCr using Recursion (04:50)
    • Tower of Hanoi Problem (26:12)
    • Let’s Code Tower of Hanoi (03:38)
    • Recursion (5 questions)
    • Quiz 1 Solutions (31:10)
  6. Arrays Representations (15 lectures) (01:53:42)
    • Introduction to Array (04:11)
    • Declarations of Array (06:09)
    • Demo – Array Declaration (04:54)
    • Static vs Dynamic Arrays (08:47)
    • Demo – Static vs Dynamic Array (04:41)
    • How to Increase Array Size (05:09)
    • Demo – Increasing Array Size (07:46)
    • 2D Arrays (10:37)
    • Demo – 2D Array (06:46)
    • Array Representation by Compiler (08:43)
    • Row Major Formula for 2D Arrays (09:37)
    • Column Major Formula for 2D Arrays (06:30)
    • Formulas for nD Arrays (11:10)
    • Formulas for 3D Arrays (03:37)
    • Arrays Representation (4 questions)
    • Solutions for Quiz 2 (15:05)
  7. Array ADT (37 lectures) (06:06:09)
    • Array ADT (04:34)
    • Demo – Array ADT (13:03)
    • Inserting in an Array (11:04)
    • Let’s Code Insert (06:49)
    • Deleting from Array (06:28)
    • Let’s Code Delete (05:46)
    • Linear Search (11:31)
    • Improving Linear Search (04:18)
    • Let’s Code Linear Search (06:26)
    • Binary Search (09:58)
    • Binary Search Algorithm (07:07)
    • Let’s Code Binary Search (06:58)
    • Analysis of Binary Search (12:46)
    • Average Case Analysis of Binary Search (11:26)
    • Get( ) Set( ) Avg( ) Max( ) functions on Array (14:34)
    • Let’s Code Get() Set() Max() on Array (08:56)
    • Reverse and Shift an Array (11:07)
    • Lest’s Code Reversing an Array (05:37)
    • Check if Array is Sorted (15:45)
    • Let’s Code to check if Array is Sorted (10:37)
    • Merging Arrays (08:49)
    • Let’s Code to Merge Arrays (07:53)
    • Set operations on Array – Union, Intersection and Difference (12:01)
    • Let’s Code Set operations on Array (09:23)
    • Let’s Code a Menu Driver program for Arrays (07:28)
    • Let’s convert C program for Array to C++ (15:42)
    • Let’s Put all together in C++ program for Array (16:48)
    • Student Challenge : Finding Single Missing Element in an Array (10:59)
    • Student Challenge : Finding Multiple Missing Elements in an Array (08:05)
    • Student Challenge : Finding Missing Element in an Array Method 2 (08:03)
    • Student Challenge Finding Duplicates in a Sorted Array (12:53)
    • Student Challenge : Finding Duplicates in Sorted Array using Hashing (07:29)
    • Student Challenge : Finding Duplicates in a Unsorted Array (13:12)
    • Student Challenge : Finding a Pair of Elements with sum K (13:03)
    • Student Challenge : Finding a Pair of Elements with sum K in Sorted Array (07:35)
    • Student Challenge : Finding Max and Min in a single Scan (09:01)
    • Array ADT (5 questions)
    • Solutions for Quiz 3 (12:55)
  8. Strings (11 lectures) (02:32:01)
    • Introduction to Strings (21:24)
    • Finding Length of a String (04:39)
    • Changing Case of a String (08:03)
    • Counting Words and Vowels in a String (08:55)
    • Validating a String (06:02)
    • Reversing a String (08:44)
    • Comparing Strings and Checking Palindrome (11:02)
    • Finding Duplicates in a String (12:54)
    • Finding Duplicates in a String using Bitwise Operations (25:09)
    • Checking if 2 Strings are Anagram (distinct letters) (13:38)
    • Permutation of String (31:31)
  9. Matrices (17 lectures) (02:18:09)
    • Section Introduction (00:59)
    • Diagonal Matrix (08:40)
    • Let’s Code Diagonal Matrix (07:46)
    • C++ class for Diagonal Matrix (13:42)
    • Let’s Code C++ class for Diagonal matrix (07:03)
    • Lower Triangular Matrix Row-Major Mapping (09:26)
    • Lower Triangular Matrix Column-Major Mapping (06:38)
    • Let’s Code Lower Triangular Matrix in C (12:49)
    • Let’s Code Lower Triangular Matrix in C++ (09:45)
    • Upper Triangular Matrix Row-Major Mapping (06:46)
    • Upper Triangular Matrix Column-Major Mapping (03:21)
    • Symmetric Matrix (02:32)
    • Tri-Diagonal and Tri-Band Matrix (09:41)
    • Toeplitz Matrix (07:15)
    • Menu Driven Program for Matrices (14:57)
    • Menu Driven Program for Matrices using Functions (04:53)
    • How to Write C++ Classes for All Matrices (11:56)
    • Matrices (3 questions)
  10. Sparse Matrix and Polynomial Representation (12 lectures) (02:13:17)
    • Sparse Matrix Representation (08:46)
    • Addition of Sparse Matrices (09:17)
    • Array Representation of Sparse Matrix (11:21)
    • Let’s Code to Create Sparse Matrix (10:26)
    • Program for Adding Sparse Matrix (15:20)
    • Let’s Code to Add Sparse Matrix (13:32)
    • Let’s Code Sparse Matrix using C++ (09:09)
    • Let’s Code Sparse Matrix using C++ Continued….. (14:36)
    • Polynomial Representation (10:25)
    • Polynomial Evaluation (04:04)
    • Polynomial Addition (08:58)
    • Let’s Code Polynomial (17:23)
  11. Linked List (57 lectures) (06:53:20)
    • Why we need Dynamic Data Structure Linked List (09:16)
    • About Linked List (09:57)
    • More About Linked List (07:52)
    • Display Linked List (05:41)
    • Let’s Code Display for Linked List (10:18)
    • Recursive Display of Linked List (13:46)
    • Let’s Code Recursive Display for Linked List (03:51)
    • Counting Nodes in a Linked List (10:33)
    • Sum of All Elements in a Linked List (03:59)
    • Let’s Code Count and Sum (07:19)
    • Maximum Element in a Linked List (06:22)
    • Let’s Code Max for Linked List (03:31)
    • Searching in a Linked List (04:37)
    • Improve Searching in Linked List (08:28)
    • Let’s Code Searching in Linked List (07:58)
    • Inserting in a Linked List (16:35)
    • Let’s Code Insert for Linked List (06:34)
    • Creating a Linked List using Insert (02:23)
    • Creating a Linked List by Inserting at Last (07:03)
    • Inserting in a Sorted Linked List (06:58)
    • Let’s Code Insert in Sorted Linked List (05:46)
    • Deleting from Linked List (12:04)
    • Let’s Code Delete on Linked List (06:04)
    • Check if a Linked List is Sorted (08:14)
    • Let’s Code to check if Linked List is Sorted (02:38)
    • Remove Duplicates from Sorted Linked List (06:00)
    • Let’s Code to Remove Duplicates from Sorted Linked List (02:45)
    • Reversing a Linked List (06:50)
    • Reversing using Sliding Pointers (10:26)
    • Recursive Reverse for Linked List (04:18)
    • Let’s Code Reversing a Linked List (06:36)
    • Concatenating 2 Linked Lists (03:04)
    • Merging 2 Linked Lists (14:23)
    • Let’s Code to Concatenate and Merge Linked Lists (08:36)
    • Check for LOOP in Linked List (09:16)
    • Let’s Code to Check LOOP (04:09)
    • Let’s Code a C++ class for Linked List (06:41)
    • Circular Linked List (06:55)
    • Display Circular Linked List (08:29)
    • Let’s Code Circular Linked List (07:06)
    • Inserting in a Circular Linked List (10:21)
    • Let’s Code Insert for a Circular Linked List (05:56)
    • Deleting From Circular Linked List (06:35)
    • Let’s Code Delete for Circular Linked List (04:57)
    • Doubly Linked List (04:12)
    • Let’s Code Doubly Linked List (05:26)
    • Insert in a Doubly Linked List (09:26)
    • Let’s Code Insert for Doubly Linked List (04:14)
    • Deleting from Doubly Linked List (08:09)
    • Let’s Code Delete for Doubly Linked List (04:14)
    • Reverse a Doubly Linked List (05:27)
    • Let’s Code Reverse for Doubly Linked List (02:20)
    • Circular Doubly Linked List (07:21)
    • Comparison of Linked List (11:09)
    • Comparison of Array with Linked List (10:54)
    • Student Challenge : Finding Middle Element of a Linked List. (10:27)
    • Student Challenge : Finding Intersecting point of Two Linked List (08:51)
    • Linked List (5 questions)
  12. Sparse Matrix and Polynomial using Linked List (3 lectures) (25:23)
    • Student Challenge : Sparse Matrix using Linked List (09:42)
    • Student Challenge: Polynomial Representation using Linked List (07:08)
    • Let’s Code Polynomial (08:33)
  13. Stack (22 lectures) (03:16:16)
    • Introduction to Stack (12:11)
    • Stack using Array (09:52)
    • Implementation os Stack using Array (16:52)
    • Let’s Code Stack using Array (12:41)
    • Stack using Linked List (05:20)
    • Stack Operations using Linked List (08:52)
    • Let’s Code Stack using Linked List (07:22)
    • Let’s Code C++ class for Stack using Linked List (06:09)
    • Parenthesis Matching (06:39)
    • Program for Parenthesis Matching (08:17)
    • Let’s Code Parenthesis Matching (04:14)
    • More on Parenthesis Matching (06:27)
    • Infix to Postfix Conversion (17:35)
    • Associativity and Unary Operators (13:19)
    • Infix to Postfix using Stack Method 1 (07:05)
    • Infix to Postfix using Stack Method 2 (03:20)
    • Program for Infix to Postfix Conversion (08:33)
    • Let’s Code Infix to Postfix Conversion (09:00)
    • Student Challenge: Infix to Postfix with Associativity and Parenthesis (09:30)
    • Evaluation of Postfix Expression (09:59)
    • Program for Evaluation of Postfix (07:50)
    • Let’s Code Evaluation of Postfix (05:09)
    • Stack (8 questions)
  14. Queues (14 lectures) (01:32:07)
    • Queue ADT (04:32)
    • Queue using Single Pointer (03:46)
    • Queue using Two Pointers (07:45)
    • Implementing Queue using Array (08:39)
    • Let’s Code Queue using Array (06:34)
    • Let’s Code Queue in C++ (05:56)
    • Drawback of Queue using Array (04:30)
    • Circular Queue (10:53)
    • Let’s Code Circular Queue (03:13)
    • Queue using Linked List (07:43)
    • Let’s Code Queue using Linked List (05:29)
    • Double Ended Queue DEQUEUE (05:08)
    • Priority Queues (11:15)
    • Queue using 2 Stacks (06:44)
    • Queue (5 questions)
  15. Trees (33 lectures) (04:03:50)
    • Terminology (11:23)
    • Number of Binary Trees using N Nodes (12:31)
    • Height vs Nodes in Binary Tree (12:46)
    • Internal Nodes vs External Nodes in Binary Tree (03:20)
    • Strict Binary Tree (02:22)
    • Height vs Node of Strict Binary Tree (03:54)
    • Internal vs External Nodes of Strict Binary Trees (01:25)
    • n-ary Trees (06:10)
    • Analysis of n-Ary Trees (08:15)
    • Representation of Binary Tree (05:19)
    • Linked Representation of Binary Tree (03:29)
    • Full vs Complete Binary Tree (05:57)
    • Strict vs Complete Binary Tree (04:13)
    • Binary Tree Traversals (09:01)
    • Binary Tree Traversal Easy Method 1 (02:50)
    • Binary Tree Traversal Easy Method 2 (03:24)
    • Binary Tree Traversal Easy Method 3 (04:24)
    • Creating Binary Tree (07:49)
    • Program to Create Binary Tree (04:12)
    • Let’s Code Creating Binary Tree (13:16)
    • Let’s Code Creating Binary Tree in C++ (23:34)
    • Preorder Tree Traversal (12:50)
    • Inorder Tree Traversals Functions (10:00)
    • Iterative Preorder (09:40)
    • Iterative Inorder (09:19)
    • Let’s Code Iterative Traversals (05:28)
    • Level Order Traversal (06:21)
    • Let’s Code Level Order Traversal (03:40)
    • Can we Generate Tree from Traversals (06:28)
    • Generating Tree from Traversals (07:14)
    • Height and Count of Binary Tree (09:29)
    • Let’s Code Height and Count (03:15)
    • Student Challenge : Count Leaf Nodes of a Binary Tree (10:32)
    • Binary Trees (5 questions)
  16. Binary Search Trees (11 lectures) (01:34:38)
    • BST intro (05:22)
    • Searching in a Binary Search Tree (09:55)
    • Inserting in a Binary Search Tree (06:38)
    • Recursive Insert in Binary Search Tree (06:39)
    • Creating a Binary Search Tree (02:47)
    • Let’s code Binary Search Tree (13:59)
    • Deleting from Binary Search Tree (10:07)
    • Let’s Code Recursive Insert and Delete on BST (19:18)
    • Generating BST from Preorder (08:58)
    • Program for Generating BST from Preorder (06:16)
    • Drawbacks of Binary Search Tree (04:39)
    • Binary Search Trees (5 questions)
  17. AVL Trees (8 lectures) (01:31:31)
    • Introduction to AVL Trees (06:06)
    • Inserting in AVL with Rotations (14:42)
    • General form of AVL Rotations (13:34)
    • Let’s Code LL Rotation on AVL (18:29)
    • Let’s Code LR Rotation on AVL (05:23)
    • Generating AVL Tree (12:47)
    • Deletion from AVL Tree with Rotations (08:00)
    • Height Analysis of AVL Trees (12:30)
  18. Search Trees (9 lectures) (02:08:40)
    • 2-3 Trees (34:21)
    • 2-3-4 Trees (13:22)
    • Red-Black Trees Introduction (05:14)
    • Red-Black Tree creation (22:54)
    • Red-Black Trees vs 2-3-4 Trees (05:01)
    • Creating Red-Black Tree similar to Creating 2-3-4 Tree (11:27)
    • Red-Black Tree Deletion Cases (14:54)
    • Red-Black Tree Deletion Examples (09:28)
    • Red-Black Tree vs 2-3-4 Tree Deletion (11:59)
  19. Heap (8 lectures) (01:11:08)
    • Introduction to Heap (04:04)
    • Inserting in a Heap (07:40)
    • Program to Insert in a Heap (04:22)
    • Creating a Heap (11:17)
    • Deleting from Heap and Heap Sort (12:34)
    • Let’s Code Heap Sort (15:00)
    • Heapify – Faster Method for creating Heap (08:47)
    • Heap as Priority Queue (07:24)
  20. Sorting Techniques (29 lectures) (04:13:09)
    • Criteria used for Analysing Sorts (08:34)
    • Bubble Sort (20:09)
    • Let’s Code Bubble Sort (06:29)
    • Insertion Sort (06:03)
    • Insertion Sort Continued…. (09:05)
    • Program for Insertion Sort (05:05)
    • Analysis of Insertion Sort (04:22)
    • Let’s Code Insertion Sort (02:34)
    • Comparing Bubble and Insertion Sort (02:41)
    • Selection Sort (11:08)
    • Program for Selection Sort (02:41)
    • Analysis of Selection Sort (03:09)
    • Let’s Code Selection Sort (02:25)
    • Idea behind Quick Sort (06:36)
    • Quick Sort (08:23)
    • Analysis of Quick Sort (10:12)
    • Analysis of Quick Sort Continued….. (12:32)
    • Let’s Code Quick Sort (06:33)
    • Merging (17:08)
    • Iterative Merge Sort (11:28)
    • Let’s Code Iterative Merge Sort (07:41)
    • Recursive Merge Sort (18:01)
    • Let’s Code Recursive Merge Sort (02:47)
    • Count Sort (12:01)
    • Let’s Code Count Sort (06:26)
    • Bin / Bucket Sort (10:10)
    • Radix Sort (14:21)
    • Shell Sort (21:19)
    • Let’s Code Shell Sort (03:06)
  21. Hashing Technique (8 lectures) (01:28:56)
    • Introduction to Hashing (16:00)
    • Chaining (15:04)
    • Let’s Code Chaining (06:52)
    • Linear Probing (17:22)
    • Let’s Code Linear Probing (09:40)
    • Quadratic Probing (04:42)
    • Double Hashing (09:26)
    • Hash Function Ideas (09:50)
    • Hashing (5 questions)
  22. Graphs (16 lectures) (03:08:19)
    • Introduction to Graphs (08:43)
    • Representation of Undirected Graph (14:04)
    • Representation of Directed Graphs (06:32)
    • Breadth First Search (17:44)
    • Program for BFS (09:02)
    • Depth First Search (10:33)
    • Program for DFS (04:10)
    • Let’s Code BFS & DFS (12:27)
    • Spanning Trees (07:50)
    • Prim’s Minimum Cost Spanning Tree (06:58)
    • Prim’s Program (29:13)
    • Let’s Code Prim’s using (11:48)
    • Kruskal’s Minimum Cost Spanning Tree (06:16)
    • Disjoint Subsets (13:51)
    • Kruskal’s Program (19:33)
    • Let’s Code Kruskla’s Program (09:35)
    • Graphs (5 questions)
  23. Asymptotic Notations (2 lectures) (10:43)
    • Asymptotic Notations Big Oh , Omega , Theta (10:35)
    • PDF for All Programs (00:08)

You may be new to Data Structure or you have already Studied and Implemented Data Structures but still you feel you need to learn more about Data Structure in detail so that it helps you solve challenging problems and used Data Structure efficiently.


This 53 hours of the course covers each topic in greater detail, every topic is covered on Whiteboard which will improve your Problem Solving and Analytical Skills. Every Data Structure is discussed, analysed, and implemented with Practical line-by-line coding.

Source code for all Programs is available for you to download

About Instructor

I am the Instructor of this course, I have been teaching this course to university students for a long period of time, I know the pulse of students very well, I know how to present the topic so that it’s easy to grasp for students.

I know how to use White board to explain the topic and also to make it memorable. Remembering the thing and using them in right place is more important than just understanding the topic.

After Completing Course

 After completing this course you will be confident enough to take up any challenging problem in coding using Data Structures.

Course Contents

1. Recursion

2. Arrays Representation

3. Array ADT

4. Linked List

5. Stack

6. Queues

7. Trees

8. Binary Search Tree

9. AVL Trees

10. Graphs

11. Hashing Technique

Reviews

One of the best courses for mastering Data Structures & Algorithms using C & C++. As we are focusing on C language at the university, the course was very helpful for me. The content of our university lessons related to Data Structures & Algorithms is almost identical to this course.

This is a full-fledged course for beginners in advance. It was more than what I expected, every concept is taught thoroughly with whiteboard demonstrations followed by detailed explanations of the code.

Abdul Sir has just an amazing style of teaching. I loved these courses throughout the journey and enjoyed the data structures and algorithms with patience and gained a lot of confidence.

Who this course is for:

  • Developers who want to get the Deepest knowledge of Data Structure
  • Undergraduates who want to Learn Data Structures Perfectly

Download Mastering Data Structures & Algorithms using C and C++

Share Post

Leave a Comment