Data Structures & Algorithms ! 

S01 - L01 -- Course Breakdown

S01 - L02 -- What is DS and Algo

S01 - L03 -- Why companies ask DS

S01 - L04 -- DS in every day life

S01 - L05 -- Types of DS

S01.1-L01--What is Recursion

S01.1-L02--Why learn Recursion

S01.1-L03--Format of Recursion Method

S01.1-L04--How Recurssion works internally

S01.1-L05--Finding Factorial using Recursion

S01.1-L06--Finding Fibonacci using Recursion

S01.1-L07--Recursion vs Iteration

S01.1-L08--When to Use & Avoid Recursion

S01.1-L09--Practical Uses of Recursion

S02-L01 -- What is Algo Run Time Analysis

S02-L02 -- What are Notations

S02-L03 -- Examples of Notations

S02-L04 -- Examples of Time Complexity

S02-L05 -- Finding Time Complexity of Iterative Algo

S02-L06 -- Finding Time Complexity of Recursive Algo#1

S02-L07 -- Finding Time Complexity of Recursive Algo#2

S03 - L01 -- What and Why of Array

S03 - L02 -- Types of Array

S03 - L03 -- How is Array represented in Memory

S03 - L04 -- Create an Array

S03 - L05 -- Insert Traverse in 1D Array

S03 - L06 -- Access Search Delete in 1D Array

S03 - L07 -- Code 1D Array

S03 - L08 -- Time Complexity of 1D Array

S03 - L09 -- Create 2D Array

S03 - L10 -- 2D Array operations

S03 - L11 -- Time Complexity of 2D Array

S03 - L12 -- When to use Array

S03 - L13 -- Code 2D Array

S03 - L14 -- Practical uses of Array

S04 - L01 -- What is linked list

S04 - L02 -- Linked list vs Array

S04 - L03 -- Components of LinkedList

S04 - L04 -- Types of LinkedList

S04 - L05 -- Why so many types of LinkedList

S04 - L06 -- How is LinkedList stored in Memory

S04 - L07 -- Creation of Single LinkedList (SLL)

S04 - L08 -- Insertion in SLL - Dry Run

S04 - L09 -- Insertion in SLL - Algo

S04 - L10 -- Traversal of SLL

S04 - L11 -- Search node in SLL

S04 - L12 -- Deletion of node from SLL - Dry Run

S04 - L13 -- Deletion of node from SLL - Algo

S04 - L14 -- Delete entire SLL

S04 - L15 -- Time Complexity of SLL

S04 - L16 -- Creation of Circular Single LinkedList (CSLL)

S04 - L17 -- Insertion of data in CSLL - Dry Run

S04 - L18 -- Insertion of data in CSLL - Algo

S04 - L19 -- Traverse CSLL

S04 - L20 -- Search a node in CSLL

S04 - L21 -- Delete a node from CSLL - Dry Run

S04 - L22 -- Deletion of node from CSLL - Algo

S04 - L23 -- Deletion of entire CSLL

S04 - L24 -- Time Complexity of CSLL

S04 - L25 -- Create Double Linked List (DLL)

S04 - L26 -- Insert node in DLL - Dry Run

S04 - L27 -- Insert node in DLL - Algo

S04 - L28 -- Traverse DLL

S04 - L29 -- Reverse Traversal of DLL

S04 - L30 -- Search a node in DLL

S04 - L31 -- Delete a node from DLL - Dry Run

S04 - L32 -- Delete a node from DLL - Algo

S04 - L33 -- Delete entire DLL

S04 - L34 -- Time Complexity of DLL

S04 - L35 -- Create Double Circular LinkedList (CDLL)

S04 - L36 -- Insert node in CDLL - Dry Run

S04 - L37 -- Insert node in CDLL - Algo

S04 - L38 -- Traverse CDLL

S04 - L39 -- Reverse traverse CDLL

S04 - L40 -- Search a node in CDLL

S04 - L41 -- Delete a node from CDLL - Dry Run

S04 - L42 -- Delete a node from CDLL - Algo

S04 - L43 -- Delete entire CDLL

S04 - L44 -- Time Complexity of CDLL

S04 - L45 -- SLL vs CSLL vs DLL vs DLL

S04 - L46 -- Practical uses of LinkedList

L01 -- What and Why of Stack

L02 -- ARRAY - Create & Push

L03 -- ARRAY - Pop, Peek, isEmpty, isFull, Delete

L04 -- LinkedList - Create, Push, Pop

L05 -- LinkedList - Peek, Delete

L06 -- When to use or avoid Stack

S06 - L01 -- What and Why of Queue

S06 - L02 -- LINEAR QUEUE(Array) - Create, Enqueue

S06 - L03 -- LINEAR QUEUE((Array)) - deQueue, isEmpty, isFull, Delete

S06 - L04 -- Why Circular Queue

S06 - L05 -- CIRCULAR QUEUE(Array) - Enqueue

S06 - L06 -- CIRCULAR QUEUE(Array) - Dequeue

S06 - L07 -- CIRCULAR QUEUE(Array) - Peek, isEmpty, isFull, Delete

S06 - L08 -- LINEAR QUEUE(LL) - Enqueue

S06 - L09 -- LINEAR QUEUE(LL) - DeQueue

S06 - L10 -- LINEAR QUEUE(LL) - Peek, isEmpty, Delete

S06 - L11 -- Array vs LinkedList Implementation

S08.01 - L01 -- What is Tree

S08.01 - L02 -- Why learn Tree

S08.01 - L03 -- Tree Terminologies - Part#1

S08.01 - L03 -- Tree Terminologies - Part#2

S08.01 - L04 -- What & Why of Binary Ttree

S08.01 - L05 -- Types of Binary Tree

S08.01 - L06 -- How is Tree Represented in Code

S08.01 - L07 -- Create blank Binary Tree(LL)

S08.01 - L08 -- Pre-order traversal Binary Tree(LL)

S08.01 - L09 -- In-order traversal Binary Tree(LL)

S08.01 - L10 -- Post-order traversal Binary Tree(LL)

S08.01 - L11 -- Level-order traversal Binary Tree(LL)

S08.01 - L12 -- Search for value in Binary Tree(LL)

S08.01 - L13 -- Insert value in Binary Tree(LL)

S08.01 - L14 -- Delete value from Binary Tree(LL)

S08.01 - L15 -- Delete Binary Tree(LL)

S08.01 - L16 -- Create Binary Tree(Array)

S08.01 - L17 -- Insert value in Binary Tree(Array)

S08.01 - L18 -- Search for value in Binary Tree(Array)

S08.01 - L19 -- Inorder traversal of Binary Tree(Array)

S08.01 - L20 -- Pre-order traversal of Binary Tree(Array)

S08.01 - L21 -- Post-order traversal of Binary Tree(Array)

S08.01 - L22 -- Level-order traversal of Binary Tree(Array)

S08.01 - L23 -- Delete node from Binary Tree(Array)

S08.01 - L24 -- Delete Binary Tree(Array)

S08.01 - L25 -- Binary Tree (Array vs Linked List)

S08.02 - L01 -- What & Why of BST

S08.02 - L02 -- Creation & Searching in BST

S08.02 - L03 -- Traversing a BST

S08.02 - L04 -- Inserting a node in BST

S08.02 - L05 -- Deleting a node from BST

S08.02 - L06 -- Deleting a BST

S08.03 - L01 -- Why learn AVL Tree

S08.03 - L02 -- What is AVL Tree

S08.03 - L03 -- Create Search Traverse AVL Tree

S08.03 - L04 -- Insert in AVL_LL Theory

S08.03 - L05 -- Insert in AVL_LL Algorithm

S08.03 - L06 -- Insert in AVL LR

S08.03 - L07 -- Insert in AVL RR

S08.03 - L08 -- Insert in AVL RL

S08.03 - L09 -- Insert End to End Case

S08.03 - L10 -- Delete LL LR RR RL

S08.03 - L11 -- Delete End to End Case

S08.03 - L12 -- Delete AVL Tree & Tree Comparison

S08.04 - L01 -- What Why and Type of Heap

S08.04 - L02 -- Create, Peek, Size of Heap

S08.04 - L03 -- Insert element in Heap

S08.04 - L04 -- Extract and Delete from Heap

S08.04 - L05 -- Why avoid Reference based implementation ?

S08.05 - L01 -- What and Why of Trie

S08.05 - L02 -- Create Insert in Trie

S08.05 - L03 -- Search a String in Trie

S08.05 - L04 -- Delete a String from Trie

S08.05 - L05 -- Practical Uses of Trie

S09 - L01 -- Introduction to Hashing

S09 - L02 -- Why learn Hashing ?

S09 - L03 -- Introduction to Hash Functions

S09 - L04 -- Types of Collision Resolution Techniques

S09 - L05 -- What happens when Hash Table is full ?

S09 - L06 -- Collision Resolution Techniques Compared

S09 - L07 -- Practical Use of Hashing

S09 - L08 -- Hashing vs Other DS

S10 - L01 -- What and Why of Sorting

S10 - L02 -- Types of Sorting Techniques

S10 - L03 -- Sorting Terminologies

S10 - L04 -- Bubble Sort

S10 - L05 -- Selection Sort

S10 - L06 -- Insertion Sort

S10 - L07 -- Bucket Sort

S10 - L08 -- Merge Sort

S10 - L09 -- Quick Sort Part#1

S10 - L09 -- Quick Sort Part#2

S10 - L10 -- HeapSort

S10 - L11 -- Sorting Techniques compared

S11 - L01 -- What and Why of Graphs

S11 - L02 -- Graph Terminologies

S11 - L03 -- Types of Graphs

S11 - L04 -- Graph Representation in Code

S11 - L05 -- BFS Algorithm

S11 - L06 -- BFS Time Complexity

S11 - L07 -- DFS Algorithm

S11 - L08 -- DFS Time Complexity

S11 - L09 -- BFS vs DFS

S11 - L10 -- What is Topological Sort

S11 - L11 -- Topological Sort Dry Run

S11 - L12 -- Why Topological Sort Works

S11 - L13 -- Topological Sort Algorithm

S11 - L14 -- What is Single Source Shortest Path Problem(SSSP)

S11 - L15 -- BFS for SSSP

S11 - L16 -- Why BFS does not works for Weighted Graph SSSP

S11 - L17 -- Why DFS does not works for SSSP

S11 - L18 -- Dijkstra for SSSP

S11 - L19 -- Why Dijkstra does not work for Negative Cycle

S11 - L20 -- BellmanFord Dry run for SSSP

S11 - L21 -- BellanFord Algorithm for SSSP

S11 - L22 -- How Bellman Ford works for Negative Cycle

S11 - L23 -- Why BellmanFord runs for V-1 times

S11 - L24 -- BFS vs Dijkstra vs BellmanFord

S11 - L25 -- What is All Pair Shortest Path Problem(APSP)

S11 - L26 -- Dry run of BFS Dijkstra Bellman for APSP

S11 - L27 -- Floyd Warshall Algorithm for APSP

S11 - L28 -- Why Floyd Warshall Algorithm always works

S11 - L29 -- Why Floyd does not works for Negative Cycle

S11 - L30 -- BFS vs Dijkstra vs Bellman vs Floys

S11 - L31 -- What is Minimum Spanning Tree (MST)

S11 - L32.1 -- DisjointSet

S11 - L32.2 -- Kruskals Algorithm

S11 - L33 -- Prims Algorithm Dry Run

S11 - L34 -- Prims Algorithm Explained

S11 - L35 -- Prims vs Kruskal

S12.1 - L01 -- Magic Framework

S12.2 - L01 -- Greedy Algo Introduction

S12.2 - L02 -- Known Algos

S12.2 - L03 -- Activity Selection Problem

S12.2 - L04 -- Coin Change Problem

S12.2 - L05 -- Fractional Knapsack Problem

S12.3 - L01 -- What and Why of Divide&Conquer

S12.3 - L02 -- Binary Search, Quick, Merge Sortt

S12.3 - L03 -- Fibonacci Series

S12.3 - L04 -- Number Factor

S12.3 - L05 -- House thief

S12.3 - L06 -- Convert One String to Another

S12.3 - L07 -- Zero-One Knapsack

S12.3 - L08 -- Longest Common Subsequence

S12.3 - L09 -- Longest Palindromic Subsequence

S12.3 - L10 -- Longest Palindromic Substring

S12.3 - L11 -- Min Cost to Reach End of Array

S12.3 - L12 -- Number of Paths to reach last cell with given Cost

S12.4 - L01 -- What and Why of Dynamic Programming

S12.4 - L02 -- Top Down Approach

S12.4 - L03 -- Bottom Up Approach

S12.4 - L04 -- Is Merge Sort Dynamic Programming ?

S12.4 - L05 -- Number Factor Problem

S12.4 - L06 -- HouseThief Problem

S12.4 - L07 -- Convert One String to Another

S12.4 - L08 -- Zero One Knapsack Problem

S12.4 - L09 -- Longest Common Subsequence

S12.4 - L10 -- Longest Palindromic Subsequence

S12.4 - L11 -- Longest Palindromic Substring

S12.4 - L12 -- Min Cost to Reach End of Array

S12.4 - L13 -- Ways to Reach last cell