Data Structures & Algorithms Blueprint - Part 1 (Of 2)

Master Data Structures Algorithm from scratch as it Data Structures Algorithm is the most subject of computer science

What you'll learn

All the concepts you need to understand to master DSA so that you no longer need to scratch your head (the best part is you don't need any prerequisite)

Every model of problems you can expect in an interview or college exam or gate exam

Hundreds of problems has been discussed because of which you willnot only learn theoretical concepts but also the practical stuffs

This course also focussed on lot of interview questions which are asked in coding interviews

Requirements

Have a PC with internet connection

Even ZERO knowledge in Computer Science is fine - You will understand every single concept without any difficulty - there is no scratching of head !!!

Description

Do you want to get a job in a product-based company?Data Structures and Algorithms is one subject that can literally change your life as it has the true potential to fetch you a job in a dream product-based company. But when you start to prepare for it, you have nobody to explain everything from scratch. Books are very complex to understand. Videos on the internet are incomplete. Videos in youtube offer cheap quality content which are very hard to understand. Introducing Data Structures and Algorithms Blueprint, the only course you would want to learn every single concept of Data Structures and Algorithms to crack your interviews, and college exams.This Course currently has 46+ hours of video content. And part 2 of this course covering all the remaining concepts will be released very shortly so you will have a complete resource using which you can prepare every single concept you need to crack your dream "IT JOB"Excited to start your life-changing journey? Click the ENROL NOW button and I will see you inside this amazing course which can give you FAST results with no overwhelm. And the best part is, This Course comes with a 30-day refund policy and if you are not happy with the course, then we dont deserve your money and you will get a full refund.

Overview

Section 1: WEEK 0 : Introduction to Data Structures and Algorithms

Lecture 1 Problem, Program and Algorithm Explained

Lecture 2 Data Structures - Explained From Scratch

Lecture 3 Functions Explained From Scratch

Lecture 4 Real world Examples

Section 2: WEEK 1 : Asymptotic Notations : Everything you need to know

Lecture 5 Basic Idea of Asymptotic Notations

Lecture 6 Types of Asymptotic Notations

Lecture 7 How we use Asymptotic Notations

Lecture 8 How we use Asymptotic Notations Continued

Lecture 9 Big Oh Notation Explained

Lecture 10 Why Big Oh Notation is more important

Lecture 11 Example 1

Lecture 12 Example 2

Lecture 13 Example 3

Lecture 14 Big Omega Notation Explained

Lecture 15 Example

Lecture 16 Theta Notation Explained

Lecture 17 Small Oh notation : Basic Idea

Lecture 18 Small Oh Notation Coninued

Lecture 19 Formal Definition Explained

Lecture 20 Small Omega Notation Explained

Section 3: WEEK 2 - Types of Variables

Lecture 21 Local Variables Explained

Lecture 22 Global Variables Explained

Lecture 23 Static Variables Explained

Lecture 24 Difference between Scope and Lifetime of a Variable

Section 4: WEEK 2 - Time Complexity From Scratch

Lecture 25 Example Model 1

Lecture 26 Example Model 2

Lecture 27 Example Model 3

Lecture 28 Example Model 4

Lecture 29 Example Model 5

Lecture 30 Example Model 6

Lecture 31 Example Model 7

Lecture 32 Example Model 8

Lecture 33 Example Model 9

Lecture 34 Example Model 10

Lecture 35 Example Model 11

Lecture 36 Important Results

Lecture 37 Comparing Functions 1

Lecture 38 Comparing Functions 3

Lecture 39 Comparing Functions 4

Lecture 40 Comparing Functions 2

Lecture 41 Comparing Functions 5

Lecture 42 Comparing Functions 6

Lecture 43 Comparing Functions 7

Lecture 44 Comparing Functions 8

Lecture 45 Comparing Functions 9

Lecture 46 Comparing Functions 10

Section 5: WEEK 3 - Recursion : One of the Most Important Topics

Lecture 47 Iterative vs Recursive Solution

Lecture 48 Tracking Recursion using Stack

Lecture 49 Tracking Recursion using Stack 2

Lecture 50 Tracking Recursion using Stack 3

Lecture 51 Tracking Recursion using Tree

Lecture 52 Tracking Recursion using Stack 4

Lecture 53 Tracking Recursion using Tree 2

Lecture 54 Important Points to Note

Lecture 55 Converting Recursive Program to Recursive Equation

Lecture 56 Using Recursive Equation to Find Time Complexity of Recursive Functions

Lecture 57 Time Complexity of Recursive Functions - Example 2

Lecture 58 Time Complexity of Recursive Functions - Example 2 Continued

Lecture 59 Time Complexity of Recursive Functions - Example 3

Lecture 60 Time Complexity of Recursive Functions - Example 4

Lecture 61 Important Point to Note

Lecture 62 Another Important Point to Note

Lecture 63 Time Complexity of Recursive Functions - Example 4

Lecture 64 Time Complexity of Recursive Functions - Example 5

Lecture 65 Master's Theorem Explained

Lecture 66 More Examples on Master's Theorem 1

Lecture 67 More Examples on Master's Theorem 2

Lecture 68 More Examples on Master's Theorem 3

Lecture 69 More Examples on Master's Theorem 4

Section 6: WEEK 3 - Space Complexity From Scratch

Lecture 70 Space Complexity of Iterative Functions

Lecture 71 Space Complexity of Recursive Functions

Lecture 72 Summary of Space Complexity

Lecture 73 Space Complexity Example

Section 7: WEEK 4 - Arrays : The Most Basic & Important Data Structure From Scratch

Lecture 74 Array Data Structure Explained from Scratch

Lecture 75 Arrays Starting with Index 0 vs Index 1

Lecture 76 RMO Representation of a 2D Array

Lecture 77 CMO Representation of a 2D Array

Lecture 78 Problem on Row Major Order Representation of an Array

Section 8: WEEK 4 - Operators : Simple Topic But Comes Very Handy When Solving Output Quest

Lecture 79 Precedence of Operators

Lecture 80 Associativity of Operators

Section 9: WEEK 5 - Everything You Need To Know About Pointers : The Most Favourite Topic F

Lecture 81 Pointers, Address of Operator and Dereference Operator

Lecture 82 Difference between Call By Value and Call By Reference

Lecture 83 Pointers and Arrays Explained

Lecture 84 Pointers and Arrays Continued

Lecture 85 Valid Pointer Operations

Lecture 86 Character Arrays Explained

Lecture 87 Character Pointers Explained

Lecture 88 Character Strings Explained

Lecture 89 Array of Pointers Explained with Example

Lecture 90 Array of Pointers Continued

Lecture 91 Difference between Array of Pointers and 2-Dimensional Arrays

Lecture 92 Pointer Arithmatic Explained

Lecture 93 Difference between Array of Pointers and Pointer to an Array

Lecture 94 How Pointers can be used with 2-D Arrays

Lecture 95 One More Example to explain Pointers and 2-D Arrays

Lecture 96 Problem 1

Lecture 97 Problem 2

Lecture 98 Passing 1D Arrays and 2D arrays to a function

Lecture 99 Using Pre and Post Inc/Dec Operators with Pointers

Lecture 100 Find the Output for this Program

Lecture 101 Dereference Multiple Pointers

Lecture 102 Problem on Pointer to Pointer, Post vs Pre Increment/Decrement

Section 10: WEEK 6 - Everything You Need To Know About Structures : The Base Behind Many Upc

Lecture 103 Structure Explained from Scratch

Lecture 104 Difference between Local and Global Structures

Lecture 105 Another Way of Creating Structure Variables

Lecture 106 Summary of Structure Concepts

Lecture 107 Problem

Lecture 108 Another Point to Note

Lecture 109 Nested Structures Explained

Lecture 110 Pointer to Structure explained

Lecture 111 How to Pass a Structure to another Function using Call by Reference

Lecture 112 Problem on Structures

Lecture 113 Problem on Structures Continued

Lecture 114 Self Referential Structures Explained

Section 11: WEEK 6 - Dynamic Memory Allocation From Scratch

Lecture 115 Void Pointers Explained

Lecture 116 Void Pointers Continued

Lecture 117 Malloc Explained

Lecture 118 Malloc Continued

Lecture 119 Dynamic Memory Allocation Explained

Lecture 120 Difference between the terms "Static" & "Dynamic"

Lecture 121 Creating a Node in Heap Memory

Section 12: WEEK 7 - Everything You Need To Know About Linked List

Lecture 122 Append Operation

Lecture 123 Let's Write Code : Append Operation Continued

Lecture 124 Let's Write Code : How Append Function Works

Lecture 125 Time Complexity of Append Function

Lecture 126 Space Complexity of Append Function

Lecture 127 Let's Write Code : Insert at the Beginning

Lecture 128 Time & Space Complexity : Insert at the Beginning

Lecture 129 Let's Write Code : Finding Length of Linked List

Lecture 130 Time & Space Complexity : Finding Length of Linked List

Lecture 131 Let's Write Code : Printing the Elements of a Linked List

Lecture 132 Time & Space Complexity : Printing the elements of a Linked List

Lecture 133 Let's Write Code : Adding a New Node after a Position in a Linked List

Lecture 134 Time & Space Complexity : Adding a New Node after a Position

Lecture 135 Let's Write Code : Deleting a Node at a Position in a Linked List

Lecture 136 Let's Write Code : Deleting a Node at a Position Continued

Lecture 137 Time & Space Complexity : Deleting a Node at a Position

Lecture 138 Let's Write Code : Reversing a Linked List : Iterative Approach

Lecture 139 Time & Space Complexity : Reversing a Linked List - Iterative Approach

Lecture 140 Let's Write Code : Reversing a Linked List - Recursive Approach

Lecture 141 Let's Write Code : Reversing a Linked List - Recursive Approach Continued

Lecture 142 Time Complexity of Recursive Reversal

Lecture 143 Time Complexity of Recursive Reversal Continued

Lecture 144 Space Complexity of Recursive Reversal

Lecture 145 Let's Write Code : Printing all the Elements of Linked List and its Reverse

Lecture 146 Time Complexity : Printing all the Elements of a Linked List and its Reverse

Lecture 147 Tracking Recursion of Printandreverse using Stack

Lecture 148 Tracking Recursion of Printandreverse using Tree

Lecture 149 Let's Write Code : Deleting a Node with a Particular Value

Lecture 150 Problem 1

Lecture 151 Concept of Short Circuiting

Lecture 152 Problem 2

Lecture 153 Problem 2 Continued

Lecture 154 Random Access

Lecture 155 Inserting to a Collection of Elements

Lecture 156 More on Arrays vs Linked List

Lecture 157 More on Arrays vs Linked List

Lecture 158 Difference between Circular and Normal linked list

Lecture 159 Let's Write Code : Finding Length of a Circular Linked List

Lecture 160 Let's Write Code : Printing all the Elements of a Circular Linked List

Lecture 161 Let's Write Code : Insert at the End of a Circular Linked List

Lecture 162 Let's Write Code : Insert at the Front of a Circular Linked List

Lecture 163 Let's Write Code : Delete at the Front of a Circular Linked List

Lecture 164 Let's Write Code : Insert at the End of a Circular Linked List

Lecture 165 Doubly Linked List Explained

Lecture 166 Let's Write Code : Insert at the Front of a Doubly Linked List

Lecture 167 Let's Write Code : Insert at the End of a Doubly Linked List

Lecture 168 Let's Write Code : Insert at a Position of a Doubly Linked List

Lecture 169 Let's Write Code : Insert at a Position of a Doubly Linked List Continued

Lecture 170 Let's Write Code : Time Complexity : Insert at a Position of a Doubly Linked Lis

Lecture 171 Let's Write Code : Deletion at the Front of the Doubly Linked List

Lecture 172 Let's Write Code : Deletion at the End of the Doubly Linked List

Lecture 173 Let's Write Code : Deletion of a Node at a Position

Lecture 174 Time & Space Complexity : Deletion of a Node at a Position

Section 13: WEEK 8 - Everything You Need To Know About Stack Data Structure

Lecture 175 Stack Data Structure Explained

Lecture 176 Let's Write Code : Implementing Stack using Array : Push

Lecture 177 Let's Write Code : Implementing Stack using Array : Pop, Peak, Display

Lecture 178 Drawbacks of Array Implementation of Stack

Lecture 179 Let's Write Code : Implementing Stack using Linked List

Lecture 180 Algorithm to Check for Balanced Paranthesis

Lecture 181 Time & Space Complexity of Algorithm Which Checks Balanced Paranthesis

Lecture 182 Why this problem is Important ?

Lecture 183 Infix Expression

Lecture 184 Infix Expression to Postfix/Prefix Expression Conversion

Lecture 185 Infix to Postfix Conversion and Evaluation

Lecture 186 Evaluating Postfix Expression using Stack

Lecture 187 Evaluating Prefix Expression using Stack

Lecture 188 Infix to Postfix Conversion using Stack

Lecture 189 Infix to Postfix Conversion using Stack Continued

Lecture 190 Dealing with Brackets in Infix Expression during Conversion

Section 14: WEEK 9 - Everything You Need To Know About Queue Data Structure

Lecture 191 Queue Data Structure Explained

Lecture 192 Implement Queue using Front and Rear Variables

Lecture 193 Let's Write Code : How Enqueue is performed using Rear Variable

Lecture 194 Let's Write Code : How Dequeue is performed using Front Variable

Lecture 195 Drawbacks of Implementing a Queue using Normal Array

Lecture 196 Let's Write Code : Queue using Circular Array instead of Normal Array

Lecture 197 Time & Space Complexity : Array Implementation of Queue

Lecture 198 Let's Write Code : Printing all the Elements of a Queue

Lecture 199 Problem 1

Lecture 200 Problem 2

Lecture 201 Problem 2 Continued

Lecture 202 How Queue is Implemented using Linked List

Lecture 203 Let's Write Code : Enqueue in Linked List Implementation

Lecture 204 Let's Write Code : Dequeue in Linked List Implementation

Lecture 205 Concept of Imitating a Queue using 2 Stacks

Lecture 206 Enqueue and Dequeue using Push1, Pop1, Push2 and Pop2

Lecture 207 Let's Write Code : Queue using 2 Stacks

Lecture 208 Problem 3

Lecture 209 Problem 4

Lecture 210 Problem 5

Section 15: WEEK 10 & 11 - My Favourite Data Structure From Scratch : Binary Trees

Lecture 211 Important Terminologies

Lecture 212 Important Terminologies Continued

Lecture 213 What are Binary Trees

Lecture 214 Binary Tree Representation

Lecture 215 Let's Write Code : Creating Binary Trees in the Heap Memory

Lecture 216 Array Representation of Binary Trees

Lecture 217 Depth of a node, Height of Node and Height of a Tree

Lecture 218 Minimum number of Nodes Possible in a Binary Tree of Height "h"

Lecture 219 Complete vs Full vs Perfect Binary Tree

Lecture 220 Maximum number of Nodes Possible in a Binary Tree of Height "h"

Lecture 221 Maximum Height for a Binary Tree with "n" Nodes

Lecture 222 Minimum Height for a Binary Tree with "n" Nodes

Lecture 223 Tree Traversal and its Types

Lecture 224 Our Assumption

Lecture 225 Preorder Traversal with Code

Lecture 226 Inorder Traversal with Code

Lecture 227 Postorder Traversal with Code

Lecture 228 Preorder Traversal Continued

Lecture 229 Inorder Traversal Continued

Lecture 230 Postorder Traversal Continued

Lecture 231 Space Complexity : All 3 Traversals

Lecture 232 Time Complexity : All 3 Traversals

Lecture 233 Level Order Traversal Explained

Lecture 234 Let's Write Code : Level Order Traversal

Lecture 235 Level Order Traversal : Another Popular Way of Coding

Lecture 236 More Insights to the Previous Video

Lecture 237 Let's Write Code : How Enqueue Function Works during Level Order Traversal

Lecture 238 Let's Write Code : How Dequeue Function Works during Level Order Traversal

Lecture 239 Time & Space Complexity : Level Order Traversal

Lecture 240 Relationship between Number of Leaf Nodes and Number of Internal Nodes

Lecture 241 Preorder Traversal without using Recursion

Lecture 242 Let's Write Code : Preorder Traversal without using Recursion

Lecture 243 Let's Write Code : Iterative Preorder - Alternate Approaches

Lecture 244 Let's Write Code : Using Global Structure for Stack instead of Global Variable

Lecture 245 Let's Write Code : Push() and Pop() during Iterative Preorder Traversal

Lecture 246 Time & Space Complexity : Iterative Preorder Traversal

Lecture 247 Let's Write Code : Iterative Inorder Traversal

Lecture 248 Iterative Postorder Traversal Explained

Lecture 249 Example to understand how Iterative Postorder Traversal Algorithm Works

Lecture 250 Let's Write Code : Iterative Postorder Traversal

Lecture 251 Time & Space Complexity : Iterative Postorder Traversal

Lecture 252 Number of Binary Trees possible with n Nodes

Lecture 253 Constructing Binary Trees from Traversals

Lecture 254 Constructing Binary Trees from Inorder & Preorder Traversal

Lecture 255 Constructing Binary Trees from Inorder & Postorder Traversal

Lecture 256 Let's Write Code : Construct Binary Tree From Inorder & Preorder Traversal

Lecture 257 Let's Write Code : Construct Binary Tree From Inorder & Preorder Traversal Conti

Lecture 258 Let's Write Code : Construct Binary Tree From Inorder & Preorder Traversal Conti

Lecture 259 Time & Space Complexity : Constructing Binary Tree From Inorder & Preorder Trave

Lecture 260 Assignment : Constructing Binary Tree from Inorder & Postorder Traversal

Lecture 261 Let's Write Code : Finding Number of Nodes in a Binary Tree

Lecture 262 Time & Space Complexity : Finding Number of Nodes in a Binary Tree

Lecture 263 Let's Write Code : Finding the Height of a Binary Tree

Lecture 264 Time & Space Complexity : Finding the Height of a Binary Tree

Lecture 265 Let's Write Code : Finding the Number of Leaf Nodes in a Binary Tree

Lecture 266 Let's Write Code : Finding the Number of Internal Nodes in a Binary Tree

computer science students as this is the #1 subject in computer science which has the true potential to change your life,Software engineers who are really frustrated with your salary in service based company - you have to switch to a product based company as early as possible and the only way to do that is to master this one subject,If you want to crack coding interviews of Top Product Based Companies and don't currently have the prerequisite knowledge - This is the perfect course for you !!!,if you are preparing for GATE - as this is the subject which has the maximum weightage and understanding it in depth is going to give you a massive advantage over your competition