Mastering Data Structures & Algorithms Using C And C++

Learn, Analyse and Implement Data Structure using C and C++. Learn Recursion and Sorting.

What you'll learn

Learn various Popular Data Structures and their Algorithms.

Develop your Analytical skills on Data Structure and use then efficiently.

Learn Recursive Algorithms on Data Structures

Learn about various Sorting Algorithms

Implementation of Data Structures using C and C++

Requirements

Previous knowledge of Programming in C and C++

Description

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 course covers each topic in greater details, every topic is covered on Whiteboard which will improve your Problem Solving and Analytical Skills. Every Data Structure is discussed, analysed and implemented with a Practical line-by-line coding.Source code for all Programs is available for you to downloadAbout InstructorI 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 Contents1. Recursion2. Arrays Representation3. Array ADT4. Linked List5. Stack6. Queues7. Trees8. Binary Search Tree9. AVL Trees10. Graphs11. Hashing Technique

Overview

Section 1: Before we Start

Lecture 1 Instructor's Note

Lecture 2 Introduction

Section 2: Essential C and C++ Concepts

Lecture 3 Arrays Basics

Lecture 4 Practice : Arrays Basics

Lecture 5 Structures

Lecture 6 Practice : Structures

Lecture 7 Pointers

Lecture 8 Practice : Pointers

Lecture 9 Reference in C++

Lecture 10 Practice : Reference

Lecture 11 Pointer to Structure

Lecture 12 Practice : Pointer to Structure

Lecture 13 Functions

Lecture 14 Practice : Functions

Lecture 15 Parameter Passing Methods

Lecture 16 Practice : Parameter Passing Methods

Lecture 17 Array as Parameter

Lecture 18 Practice : Array as Parameter

Lecture 19 Structure as Parameter

Lecture 20 Practice : Structure as Parameter

Lecture 21 Structures and Functions (Must Watch)

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

Lecture 23 Practice : Monolithic Program

Lecture 24 Practice : Modular Program

Lecture 25 Practice : Structure and Functions

Lecture 26 Practice : Object-Oriented Program

Lecture 27 C++ Class and Constructor

Lecture 28 Practice : C++ Class

Lecture 29 Template classes

Lecture 30 Practice : Template Class

Section 3: Required Setup for Programming

Lecture 31 Online C and C++ compiler

Lecture 32 Setup CodeBlocks and Settings

Lecture 33 Setup Dev-C++ and Settings

Lecture 34 Debugging using Dev-C++

Lecture 35 Debugging using CodeBlocks

Lecture 36 Setup Visual Studio

Lecture 37 Debugging using Visual Studio

Lecture 38 Setup Xcode

Section 4: Introduction

Lecture 39 Introduction

Lecture 40 Stack vs Heap Memory

Lecture 41 Stack vs Heap. Continued…

Lecture 42 Physical vs Logical Data Structures

Lecture 43 ADT

Lecture 44 Time and Space Complexity

Lecture 45 Time and Space Complexity from Code

Section 5: Recursion

Lecture 46 How Recursion Works ( Tracing )

Lecture 47 Generalising Recursion

Lecture 48 How Recursion uses Stack

Lecture 49 Recurrence Relation - Time Complexity of Recursion

Lecture 50 Lets Code Recursion

Lecture 51 Static and Global Variables in Recursion

Lecture 52 Let's Code Static and Global in Recursion

Lecture 53 Tail Recursion

Lecture 54 Head Recursion

Lecture 55 Tree Recursion

Lecture 56 Let's Code Tree Recursion

Lecture 57 Indirect Recursion

Lecture 58 Let's Code Indirect Recursion

Lecture 59 Nested Recursion

Lecture 60 Let's Code Nested Recursion

Lecture 61 Sum of Natural Number using Recursion

Lecture 62 Let's Code Sum of N using Recursion

Lecture 63 Factorial using Recursion

Lecture 64 Let's Code Factorial using Recursion

Lecture 65 Power using Recursion

Lecture 66 Let's Code Power Recursion

Lecture 67 Taylor Series using Recursion

Lecture 68 Let's Code Taylor Series using Recursion

Lecture 69 Taylor Series using Horner's Rule

Lecture 70 Let's Code Taylor Series Horner's Rule - Recursion

Lecture 71 Let's Code Taylor Series Iterative

Lecture 72 Fibonacci Series using Recursion - Memoization

Lecture 73 Let's Code Fibonacci

Lecture 74 nCr using Recursion

Lecture 75 Let's Code nCr using Recursion

Lecture 76 Tower of Hanoi Problem

Lecture 77 Let's Code Tower of Hanoi

Lecture 78 Quiz 1 Solutions

Section 6: Arrays Representations

Lecture 79 Introduction to Array

Lecture 80 Declarations of Array

Lecture 81 Demo - Array Declaration

Lecture 82 Static vs Dynamic Arrays

Lecture 83 Demo - Static vs Dynamic Array

Lecture 84 How to Increase Array Size

Lecture 85 Demo - Increasing Array Size

Lecture 86 2D Arrays

Lecture 87 Demo - 2D Array

Lecture 88 Array Representation by Compiler

Lecture 89 Row Major Formula for 2D Arrays

Lecture 90 Column Major Formula for 2D Arrays

Lecture 91 Formulas for nD Arrays

Lecture 92 Formulas for 3D Arrays

Lecture 93 Solutions for Quiz 2

Section 7: Array ADT

Lecture 94 Array ADT

Lecture 95 Demo - Array ADT

Lecture 96 Inserting in an Array

Lecture 97 Let's Code Insert

Lecture 98 Deleting from Array

Lecture 99 Let's Code Delete

Lecture 100 Linear Search

Lecture 101 Improving Linear Search

Lecture 102 Let's Code Linear Search

Lecture 103 Binary Search

Lecture 104 Binary Search Algorithm

Lecture 105 Let's Code Binary Search

Lecture 106 Analysis of Binary Search

Lecture 107 Average Case Analysis of Binary Search

Lecture 108 Get( ) Set( ) Avg( ) Max( ) functions on Array

Lecture 109 Let's Code Get() Set() Max() on Array

Lecture 110 Reverse and Shift an Array

Lecture 111 Lest's Code Reversing an Array

Lecture 112 Check if Array is Sorted

Lecture 113 Let's Code to check if Array is Sorted

Lecture 114 Merging Arrays

Lecture 115 Let's Code to Merge Arrays

Lecture 116 Set operations on Array - Union, Intersection and Difference

Lecture 117 Let's Code Set operations on Array

Lecture 118 Let's Code a Menu Driver program for Arrays

Lecture 119 Let's convert C program for Array to C++

Lecture 120 Let's Put all together in C++ program for Array

Lecture 121 Student Challenge : Finding Single Missing Element in an Array

Lecture 122 Student Challenge : Finding Multiple Missing Elements in an Array

Lecture 123 Student Challenge : Finding Missing Element in an Array Method 2

Lecture 124 Student Challenge Finding Duplicates in a Sorted Array

Lecture 125 Student Challenge : Finding Duplicates in Sorted Array using Hashing

Lecture 126 Student Challenge : Finding Duplicates in a Unsorted Array

Lecture 127 Student Challenge : Finding a Pair of Elements with sum K

Lecture 128 Student Challenge : Finding a Pair of Elements with sum K in Sorted Array

Lecture 129 Student Challenge : Finding Max and Min in a single Scan

Lecture 130 Solutions for Quiz 3

Section 8: Strings

Lecture 131 Introduction to Strings

Lecture 132 Finding Length of a String

Lecture 133 Changing Case of a String

Lecture 134 Counting Words and Vowels in a String

Lecture 135 Validating a String

Lecture 136 Reversing a String

Lecture 137 Comparing Strings and Checking Palindrome

Lecture 138 Finding Duplicates in a String

Lecture 139 Finding Duplicates in a String using Bitwise Operations

Lecture 140 Checking if 2 Strings are Anagram (distinct letters)

Lecture 141 Permutation of String

Section 9: Matrices

Lecture 142 Section Introduction

Lecture 143 Diagonal Matrix

Lecture 144 Let's Code Diagonal Matrix

Lecture 145 C++ class for Diagonal Matrix

Lecture 146 Let's Code C++ class for Diagonal matrix

Lecture 147 Lower Triangular Matrix Row-Major Mapping

Lecture 148 Lower Triangular Matrix Column-Major Mapping

Lecture 149 Let's Code Lower Triangular Matrix in C

Lecture 150 Let's Code Lower Triangular Matrix in C++

Lecture 151 Upper Triangular Matrix Row-Major Mapping

Lecture 152 Upper Triangular Matrix Column-Major Mapping

Lecture 153 Symmetric Matrix

Lecture 154 Tri-Diagonal and Tri-Band Matrix

Lecture 155 Toeplitz Matrix

Lecture 156 Menu Driven Program for Matrices

Lecture 157 Menu Driven Program for Matrices using Functions

Lecture 158 How to Write C++ Classes for All Matrices

Section 10: Sparse Matrix and Polynomial Representation

Lecture 159 Sparse Matrix Representation

Lecture 160 Addition of Sparse Matrices

Lecture 161 Array Representation of Sparse Matrix

Lecture 162 Let's Code to Create Sparse Matrix

Lecture 163 Program for Adding Sparse Matrix

Lecture 164 Let's Code to Add Sparse Matrix

Lecture 165 Let's Code Sparse Matrix using C++

Lecture 166 Let's Code Sparse Matrix using C++ Continued…..

Lecture 167 Polynomial Representation

Lecture 168 Polynomial Evaluation

Lecture 169 Polynomial Addition

Lecture 170 Let's Code Polynomial

Section 11: Linked List

Lecture 171 Why we need Dynamic Data Structure Linked List

Lecture 172 About Linked List

Lecture 173 More About Linked List

Lecture 174 Display Linked List

Lecture 175 Let's Code Display for Linked List

Lecture 176 Recursive Display of Linked List

Lecture 177 Let's Code Recursive Display for Linked List

Lecture 178 Counting Nodes in a Linked List

Lecture 179 Sum of All Elements in a Linked List

Lecture 180 Let's Code Count and Sum

Lecture 181 Maximum Element in a Linked List

Lecture 182 Let's Code Max for Linked List

Lecture 183 Searching in a Linked List

Lecture 184 Improve Searching in Linked List

Lecture 185 Let's Code Searching in Linked List

Lecture 186 Inserting in a Linked List

Lecture 187 Let's Code Insert for Linked List

Lecture 188 Creating a Linked List using Insert

Lecture 189 Creating a Linked List by Inserting at Last

Lecture 190 Inserting in a Sorted Linked List

Lecture 191 Let's Code Insert in Sorted Linked List

Lecture 192 Deleting from Linked List

Lecture 193 Let's Code Delete on Linked List

Lecture 194 Check if a Linked List is Sorted

Lecture 195 Let's Code to check if Linked List is Sorted

Lecture 196 Remove Duplicates from Sorted Linked List

Lecture 197 Let's Code to Remove Duplicates from Sorted Linked List

Lecture 198 Reversing a Linked List

Lecture 199 Reversing using Sliding Pointers

Lecture 200 Recursive Reverse for Linked List

Lecture 201 Let's Code Reversing a Linked List

Lecture 202 Concatenating 2 Linked Lists

Lecture 203 Merging 2 Linked Lists

Lecture 204 Let's Code to Concatenate and Merge Linked Lists

Lecture 205 Check for LOOP in Linked List

Lecture 206 Let's Code to Check LOOP

Lecture 207 Let's Code a C++ class for Linked List

Lecture 208 Circular Linked List

Lecture 209 Display Circular Linked List

Lecture 210 Let’s Code Circular Linked List

Lecture 211 Inserting in a Circular Linked List

Lecture 212 Let's Code Insert for a Circular Linked List

Lecture 213 Deleting From Circular Linked List

Lecture 214 Let's Code Delete for Circular Linked List

Lecture 215 Doubly Linked List

Lecture 216 Let's Code Doubly Linked List

Lecture 217 Insert in a Doubly Linked List

Lecture 218 Let's Code Insert for Doubly Linked List

Lecture 219 Deleting from Doubly Linked List

Lecture 220 Let's Code Delete for Doubly Linked List

Lecture 221 Reverse a Doubly Linked List

Lecture 222 Let's Code Reverse for Doubly Linked List

Lecture 223 Circular Doubly Linked List

Lecture 224 Comparison of Linked List

Lecture 225 Comparison of Array with Linked List

Lecture 226 Student Challenge : Finding Middle Element of a Linked List.

Lecture 227 Student Challenge : Finding Intersecting point of Two Linked List

Section 12: Sparse Matrix and Polynomial using Linked List

Lecture 228 Student Challenge : Sparse Matrix using Linked List

Lecture 229 Student Challenge: Polynomial Representation using Linked List

Lecture 230 Let's Code Polynomial

Section 13: Stack

Lecture 231 Introduction to Stack

Lecture 232 Stack using Array

Lecture 233 Implementation os Stack using Array

Lecture 234 Let's Code Stack using Array

Lecture 235 Stack using Linked List

Lecture 236 Stack Operations using Linked List

Lecture 237 Let's Code Stack using Linked List

Lecture 238 Let's Code C++ class for Stack using Linked List

Lecture 239 Parenthesis Matching

Lecture 240 Program for Parenthesis Matching

Lecture 241 Let's Code Parenthesis Matching

Lecture 242 More on Parenthesis Matching

Lecture 243 Infix to Postfix Conversion

Lecture 244 Associativity and Unary Operators

Lecture 245 Infix to Postfix using Stack Method 1

Lecture 246 Infix to Postfix using Stack Method 2

Lecture 247 Program for Infix to Postfix Conversion

Lecture 248 Let's Code Infix to Postfix Conversion

Lecture 249 Student Challenge: Infix to Postfix with Associativity and Parenthesis

Lecture 250 Evaluation of Postfix Expression

Lecture 251 Program for Evaluation of Postfix

Lecture 252 Let's Code Evaluation of Postfix

Section 14: Queues

Lecture 253 Queue ADT

Lecture 254 Queue using Single Pointer

Lecture 255 Queue using Two Pointers

Lecture 256 Implementing Queue using Array

Lecture 257 Let's Code Queue using Array

Lecture 258 Let's Code Queue in C++

Lecture 259 Drawback of Queue using Array

Lecture 260 Circular Queue

Lecture 261 Let's Code Circular Queue

Lecture 262 Queue using Linked List

Lecture 263 Let's Code Queue using Linked List

Lecture 264 Double Ended Queue DEQUEUE

Lecture 265 Priority Queues

Lecture 266 Queue using 2 Stacks

Section 15: Trees

Lecture 267 Terminology

Lecture 268 Number of Binary Trees using N Nodes

Lecture 269 Height vs Nodes in Binary Tree

Lecture 270 Internal Nodes vs External Nodes in Binary Tree

Lecture 271 Strict Binary Tree

Lecture 272 Height vs Node of Strict Binary Tree

Lecture 273 Internal vs External Nodes of Strict Binary Trees

Lecture 274 n-ary Trees

Lecture 275 Analysis of n-Ary Trees

Lecture 276 Representation of Binary Tree

Lecture 277 Linked Representation of Binary Tree

Lecture 278 Full vs Complete Binary Tree

Lecture 279 Strict vs Complete Binary Tree

Lecture 280 Binary Tree Traversals

Lecture 281 Binary Tree Traversal Easy Method 1

Lecture 282 Binary Tree Traversal Easy Method 2

Lecture 283 Binary Tree Traversal Easy Method 3

Lecture 284 Creating Binary Tree

Lecture 285 Program to Create Binary Tree

Lecture 286 Let's Code Creating Binary Tree

Lecture 287 Let's Code Creating Binary Tree in C++

Lecture 288 Preorder Tree Traversal

Lecture 289 Inorder Tree Traversals Functions

Lecture 290 Iterative Preorder

Lecture 291 Iterative Inorder

Lecture 292 Let's Code Iterative Traversals

Lecture 293 Level Order Traversal

Lecture 294 Let's Code Level Order Traversal

Lecture 295 Can we Generate Tree from Traversals

Lecture 296 Generating Tree from Traversals

Lecture 297 Height and Count of Binary Tree

Lecture 298 Let's Code Height and Count

Lecture 299 Student Challenge : Count Leaf Nodes of a Binary Tree

Section 16: Binary Search Trees

Lecture 300 BST intro

Lecture 301 Searching in a Binary Search Tree

Lecture 302 Inserting in a Binary Search Tree

Lecture 303 Recursive Insert in Binary Search Tree

Lecture 304 Creating a Binary Search Tree

Lecture 305 Let's code Binary Search Tree

Lecture 306 Deleting from Binary Search Tree

Lecture 307 Let's Code Recursive Insert and Delete on BST

Lecture 308 Generating BST from Preorder

Lecture 309 Program for Generating BST from Preorder

Lecture 310 Drawbacks of Binary Search Tree

Section 17: AVL Trees

Lecture 311 Introduction to AVL Trees

Lecture 312 Inserting in AVL with Rotations

Lecture 313 General form of AVL Rotations

Lecture 314 Let's Code LL Rotation on AVL

Lecture 315 Let's Code LR Rotation on AVL

Lecture 316 Generating AVL Tree

Lecture 317 Deletion from AVL Tree with Rotations

Lecture 318 Height Analysis of AVL Trees

Section 18: Search Trees

Lecture 319 2-3 Trees

Lecture 320 2-3-4 Trees

Lecture 321 Red-Black Trees Introduction

Lecture 322 Red-Black Tree creation

Lecture 323 Red-Black Trees vs 2-3-4 Trees

Lecture 324 Creating Red-Black Tree similar to Creating 2-3-4 Tree

Lecture 325 Red-Black Tree Deletion Cases

Lecture 326 Red-Black Tree Deletion Examples

Lecture 327 Red-Black Tree vs 2-3-4 Tree Deletion

Section 19: Heap

Lecture 328 Introduction to Heap

Lecture 329 Inserting in a Heap

Lecture 330 Program to Insert in a Heap

Lecture 331 Creating a Heap

Lecture 332 Deleting from Heap and Heap Sort

Lecture 333 Let's Code Heap Sort

Lecture 334 Heapify - Faster Method for creating Heap

Lecture 335 Heap as Priority Queue

Section 20: Sorting Techniques

Lecture 336 Criteria used for Analysing Sorts

Lecture 337 Bubble Sort

Lecture 338 Let's Code Bubble Sort

Lecture 339 Insertion Sort

Lecture 340 Insertion Sort Continued….

Lecture 341 Program for Insertion Sort

Lecture 342 Analysis of Insertion Sort

Lecture 343 Let's Code Insertion Sort

Lecture 344 Comparing Bubble and Insertion Sort

Lecture 345 Selection Sort

Lecture 346 Program for Selection Sort

Lecture 347 Analysis of Selection Sort

Lecture 348 Let's Code Selection Sort

Lecture 349 Idea behind Quick Sort

Lecture 350 Quick Sort

Lecture 351 Analysis of Quick Sort

Lecture 352 Analysis of Quick Sort Continued…..

Lecture 353 Let's Code Quick Sort

Lecture 354 Merging

Lecture 355 Iterative Merge Sort

Lecture 356 Let's Code Iterative Merge Sort

Lecture 357 Recursive Merge Sort

Lecture 358 Let's Code Recursive Merge Sort

Lecture 359 Count Sort

Lecture 360 Let's Code Count Sort

Lecture 361 Bin / Bucket Sort

Lecture 362 Radix Sort

Lecture 363 Shell Sort

Lecture 364 Let's Code Shell Sort

Section 21: Hashing Technique

Lecture 365 Introduction to Hashing

Lecture 366 Chaining

Lecture 367 Let's Code Chaining

Lecture 368 Linear Probing

Lecture 369 Let's Code Linear Probing

Lecture 370 Quadratic Probing

Lecture 371 Double Hashing

Lecture 372 Hash Function Ideas

Section 22: Graphs

Lecture 373 Introduction to Graphs

Lecture 374 Representation of Undirected Graph

Lecture 375 Representation of Directed Graphs

Lecture 376 Breadth First Search

Lecture 377 Program for BFS

Lecture 378 Depth First Search

Lecture 379 Program for DFS

Lecture 380 Let's Code BFS & DFS

Lecture 381 Spanning Trees

Lecture 382 Prim's Minimum Cost Spanning Tree

Lecture 383 Prim's Program

Lecture 384 Let's Code Prim's using

Lecture 385 Kruskal's Minimum Cost Spanning Tree

Lecture 386 Disjoint Subsets

Lecture 387 Kruskal's Program

Lecture 388 Let's Code Kruskla's Program

Section 23: Asymptotic Notations

Lecture 389 Asymptotic Notations Big Oh , Omega , Theta

Lecture 390 PDF for All Programs

Developer who want to get Deepest knowledge of Data Structure,Undergraduate who want to Learn Data Structures Perfectly