Data Structures & Algorithms Blueprint – Part 1 (Of 2) – [UDEMY]

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


Homepage

https://www.udemy.com/course/data-structures-and-algorithms-online-tutorial/