1. S01 -- Introduction to Data Structure & Algorithms

  1. S01 - L01 -- Course Breakdown.vtt

  2. S01 - L02 -- What is DS and Algo.vtt

  3. S01 - L03 -- Why companies ask DS.vtt

  4. S01 - L04 -- DS in every day life.vtt

  5. S01 - L05 -- Types of DS.vtt

 10. S08.03 -- AVL Tree

  1. S08.03 - L01 -- Why learn AVL Tree.vtt

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

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

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

  2. S08.03 - L02 -- What is AVL Tree.mp4

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

  4. S08.03 - L04 -- Insert in AVL_LL Theory.mp4

  5. S08.03 - L05 -- Insert in AVL_LL Algorithm.mp4

  6. S08.03 - L06 -- Insert in AVL LR.mp4

  7. S08.03 - L07 -- Insert in AVL RR.mp4

  8. S08.03 - L08 -- Insert in AVL RL.mp4

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

 11. S08.04 -- Binary Heap

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

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

  3. S08.04 - L03 -- Insert element in Heap.vtt

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

  5. S08.04 - L05 -- Why avoid Reference based implementation .mp4

 12. S08.05 -- Trie

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

  2. S08.05 - L02 -- Create Insert in Trie.vtt

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

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

  5. S08.05 - L05 -- Practical Uses of Trie.mp4

 13. S09 -- Hashing

  1. S09 - L01 -- Introduction to Hashing.vtt

  2. S09 - L02 -- Why learn Hashing .vtt

  3. S09 - L03 -- Introduction to Hash Functions.vtt

  4. S09 - L04 -- Types of Collision Resolution Techniques.vtt

  5. S09 - L05 -- What happens when Hash Table is full .vtt

  6. S09 - L06 -- Collision Resolution Techniques Compared.vtt

  7. S09 - L07 -- Practical Use of Hashing.vtt

  8. S09 - L08 -- Hashing vs Other DS.vtt

 14. S10 -- Sorting

  1. S10 - L01 -- What and Why of Sorting.vtt

  10. S10 - L09 -- Quick Sort Part#2.vtt

  11. S10 - L10 -- HeapSort.mp4

  11.1 HeapSort.zip.zip

  12. S10 - L11 -- Sorting Techniques compared.vtt

  2. S10 - L02 -- Types of Sorting Techniques.vtt

  3. S10 - L03 -- Sorting Terminologies.vtt

  4. S10 - L04 -- Bubble Sort.vtt

  5. S10 - L05 -- Selection Sort.mp4

  5.1 SelectionSort.zip.zip

  6. S10 - L06 -- Insertion Sort.vtt

  7. S10 - L07 -- Bucket Sort.mp4

  7.1 BucketSort.zip.zip

  8. S10 - L08 -- Merge Sort.vtt

  9. S10 - L09 -- Quick Sort Part#1.mp4

 15. S11 -- Graph

  1. S11 - L01 -- What and Why of Graphs.vtt

  10. S11 - L10 -- What is Topological Sort.vtt

  11. S11 - L11 -- Topological Sort Dry Run.vtt

  12. S11 - L12 -- Why Topological Sort Works.vtt

  13. S11 - L13 -- Topological Sort Algorithm.vtt

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

  15. S11 - L15 -- BFS for SSSP.mp4

  15.1 BFS.zip.zip

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

  17. S11 - L17 -- Why DFS does not works for SSSP.vtt

  18. S11 - L18 -- Dijkstra for SSSP.vtt

  19. S11 - L19 -- Why Dijkstra does not work for Negative Cycle.mp4

  2. S11 - L02 -- Graph Terminologies.mp4

  20. S11 - L20 -- BellmanFord Dry run for SSSP.mp4

  21. S11 - L21 -- BellanFord Algorithm for SSSP.mp4

  21.1 BellmanFord2.zip.zip

  22. S11 - L22 -- How Bellman Ford works for Negative Cycle.vtt

  23. S11 - L23 -- Why BellmanFord runs for V-1 times.vtt

  24. S11 - L24 -- BFS vs Dijkstra vs BellmanFord.vtt

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

  26. S11 - L26 -- Dry run of BFS Dijkstra Bellman for APSP.vtt

  27. S11 - L27 -- Floyd Warshall Algorithm for APSP.vtt

  28. S11 - L28 -- Why Floyd Warshall Algorithm always works.mp4

  29. S11 - L29 -- Why Floyd does not works for Negative Cycle.mp4

  3. S11 - L03 -- Types of Graphs.mp4

  30. S11 - L30 -- BFS vs Dijkstra vs Bellman vs Floys.mp4

  31. S11 - L31 -- What is Minimum Spanning Tree (MST).mp4

  32. S11 - L32.1 -- DisjointSet.mp4

  32.1 DisjointSet.zip.zip

  33. S11 - L32.2 -- Kruskals Algorithm.vtt

  34. S11 - L33 -- Prims Algorithm Dry Run.mp4

  35. S11 - L34 -- Prims Algorithm Explained.mp4

  35.1 Prims.zip.zip

  36. S11 - L35 -- Prims vs Kruskal.vtt

  4. S11 - L04 -- Graph Representation in Code.vtt

  5. S11 - L05 -- BFS Algorithm.vtt

  6. S11 - L06 -- BFS Time Complexity.vtt

  7. S11 - L07 -- DFS Algorithm.mp4

  8. S11 - L08 -- DFS Time Complexity.mp4

  8.1 DFS.zip.zip

  9. S11 - L09 -- BFS vs DFS.vtt

 16. S12.1 -- Magic Framework

  1. S12.1 - L01 -- Magic Framework.vtt

 17. S12.2 -- Greedy Algorithm

  1. S12.2 - L01 -- Greedy Algo Introduction.vtt

  2. S12.2 - L02 -- Known Algos.vtt

  3. S12.2 - L03 -- Activity Selection Problem.vtt

  4. S12.2 - L04 -- Coin Change Problem.mp4

  4.1 CoinChange.zip.zip

  5. S12.2 - L05 -- Fractional Knapsack Problem.vtt

 18. S12.3 -- Divide & Conquer

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

  10. S12.3 - L10 -- Longest Palindromic Substring.vtt

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

  11.1 MinCostToReachLastCellI_in2DArray_DC.zip.zip

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

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

  3. S12.3 - L03 -- Fibonacci Series.mp4

  3.1 Fibonacci_DC.zip.zip

  4. S12.3 - L04 -- Number Factor.vtt

  5. S12.3 - L05 -- House thief.mp4

  5.1 House_Thieft_DC.zip.zip

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

  7. S12.3 - L07 -- Zero-One Knapsack.mp4

  7.1 ZeroOneKnapsack_DC.zip.zip

  8. S12.3 - L08 -- Longest Common Subsequence.vtt

  9. S12.3 - L09 -- Longest Palindromic Subsequence.mp4

  9.1 LongestPalindromicSubsequence_DC.zip.zip

 19. S12.4 -- Dynamic Programming

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

  10. S12.4 - L10 -- Longest Palindromic Subsequence.vtt

  11. S12.4 - L11 -- Longest Palindromic Substring.mp4

  11.1 Java Code - LongestPalindromicSubsequence.zip.zip

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

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

  13.1 Java Code - NumberOfPathsToReachLastCell.zip.zip

  2. S12.4 - L02 -- Top Down Approach.mp4

  3. S12.4 - L03 -- Bottom Up Approach.mp4

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

  5. S12.4 - L05 -- Number Factor Problem.mp4

  5.1 Java Code - Number_Factors.zip.zip

  6. S12.4 - L06 -- HouseThief Problem.vtt

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

  7.1 Java Code - ConvertOneStringToAnother.zip.zip

  8. S12.4 - L08 -- Zero One Knapsack Problem.vtt

  9. S12.4 - L09 -- Longest Common Subsequence.mp4

  9.1 Java Code - LongestCommonSubsequence.zip.zip

 2. S01.1 -- Recursion

  1. S01.1-L01--What is Recursion.vtt

  2. S01.1-L02--Why learn Recursion.vtt

  3. S01.1-L03--Format of Recursion Method.vtt

  4. S01.1-L04--How Recurssion works internally.vtt

  5. S01.1-L05--Finding Factorial using Recursion.vtt

  6. S01.1-L06--Finding Fibonacci using Recursion.vtt

  7. S01.1-L07--Recursion vs Iteration.vtt

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

  9. S01.1-L09--Practical Uses of Recursion.vtt

 3. S02 -- Algorithm Run Time Analysis

  1. S02-L01 -- What is Algo Run Time Analysis.vtt

  2. S02-L02 -- What are Notations.vtt

  3. S02-L03 -- Examples of Notations.vtt

  4. S02-L04 -- Examples of Time Complexity.vtt

  5. S02-L05 -- Finding Time Complexity of Iterative Algo.vtt

  6. S02-L06 -- Finding Time Complexity of Recursive Algo#1.vtt

  7. S02-L07 -- Finding Time Complexity of Recursive Algo#2.vtt

 4. S03 -- Array

  1. S03 - L01 -- What and Why of Array.vtt

  10. S03 - L10 -- 2D Array operations.vtt

  11. S03 - L11 -- Time Complexity of 2D Array.vtt

  12. S03 - L12 -- When to use Array.vtt

  13. S03 - L13 -- Code 2D Array.vtt

  14. S03 - L14 -- Practical uses of Array.mp4

  2. S03 - L02 -- Types of Array.mp4

  3. S03 - L03 -- How is Array represented in Memory.mp4

  4. S03 - L04 -- Create an Array.mp4

  5. S03 - L05 -- Insert Traverse in 1D Array.mp4

  6. S03 - L06 -- Access Search Delete in 1D Array.mp4

  7. S03 - L07 -- Code 1D Array.mp4

  7.1 SingleDimentionalArray.zip.zip

  8. S03 - L08 -- Time Complexity of 1D Array.vtt

  9. S03 - L09 -- Create 2D Array.vtt

 5. S04 -- Linked List

  1. S04 - L01 -- What is linked list.vtt

  10. S04 - L10 -- Traversal of SLL.vtt

  11. S04 - L11 -- Search node in SLL.vtt

  12. S04 - L12 -- Deletion of node from SLL - Dry Run.vtt

  13. S04 - L13 -- Deletion of node from SLL - Algo.vtt

  14. S04 - L14 -- Delete entire SLL.vtt

  15. S04 - L15 -- Time Complexity of SLL.vtt

  16. S04 - L16 -- Creation of Circular Single LinkedList (CSLL).mp4

  17. S04 - L17 -- Insertion of data in CSLL - Dry Run.mp4

  18. S04 - L18 -- Insertion of data in CSLL - Algo.mp4

  19. S04 - L19 -- Traverse CSLL.mp4

  2. S04 - L02 -- Linked list vs Array.mp4

  20. S04 - L20 -- Search a node in CSLL.mp4

  21. S04 - L21 -- Delete a node from CSLL - Dry Run.mp4

  22. S04 - L22 -- Deletion of node from CSLL - Algo.mp4

  23. S04 - L23 -- Deletion of entire CSLL.mp4

  24. S04 - L24 -- Time Complexity of CSLL.mp4

  24.1 LinkedList.zip.zip

  25. S04 - L25 -- Create Double Linked List (DLL).vtt

  26. S04 - L26 -- Insert node in DLL - Dry Run.vtt

  27. S04 - L27 -- Insert node in DLL - Algo.vtt

  28. S04 - L28 -- Traverse DLL.vtt

  29. S04 - L29 -- Reverse Traversal of DLL.vtt

  3. S04 - L03 -- Components of LinkedList.vtt

  30. S04 - L30 -- Search a node in DLL.vtt

  31. S04 - L31 -- Delete a node from DLL - Dry Run.vtt

  32. S04 - L32 -- Delete a node from DLL - Algo.vtt

  33. S04 - L33 -- Delete entire DLL.vtt

  34. S04 - L34 -- Time Complexity of DLL.vtt

  35. S04 - L35 -- Create Double Circular LinkedList (CDLL).mp4

  36. S04 - L36 -- Insert node in CDLL - Dry Run.mp4

  37. S04 - L37 -- Insert node in CDLL - Algo.mp4

  38. S04 - L38 -- Traverse CDLL.mp4

  39. S04 - L39 -- Reverse traverse CDLL.mp4

  4. S04 - L04 -- Types of LinkedList.mp4

  40. S04 - L40 -- Search a node in CDLL.mp4

  41. S04 - L41 -- Delete a node from CDLL - Dry Run.mp4

  42. S04 - L42 -- Delete a node from CDLL - Algo.mp4

  43. S04 - L43 -- Delete entire CDLL.mp4

  44. S04 - L44 -- Time Complexity of CDLL.mp4

  44.1 LinkedList.zip.zip

  45. S04 - L45 -- SLL vs CSLL vs DLL vs DLL.vtt

  46. S04 - L46 -- Practical uses of LinkedList.vtt

  5. S04 - L05 -- Why so many types of LinkedList.vtt

  6. S04 - L06 -- How is LinkedList stored in Memory.vtt

  7. S04 - L07 -- Creation of Single LinkedList (SLL).vtt

  8. S04 - L08 -- Insertion in SLL - Dry Run.vtt

  9. S04 - L09 -- Insertion in SLL - Algo.vtt

 6. S05 -- Stack

  1. L01 -- What and Why of Stack.vtt

  2. L02 -- ARRAY - Create & Push.vtt

  3. L03 -- ARRAY - Pop, Peek, isEmpty, isFull, Delete.vtt

  4. L04 -- LinkedList - Create, Push, Pop.mp4

  5. L05 -- LinkedList - Peek, Delete.mp4

  5.1 Stack.zip.zip

  6. L06 -- When to use or avoid Stack.vtt

 7. S06 -- Queue

  1. S06 - L01 -- What and Why of Queue.vtt

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

  11. S06 - L11 -- Array vs LinkedList Implementation.mp4

  2. S06 - L02 -- LINEAR QUEUE(Array) - Create, Enqueue.mp4

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

  3.1 LinearQueueArray.zip.zip

  4. S06 - L04 -- Why Circular Queue.vtt

  5. S06 - L05 -- CIRCULAR QUEUE(Array) - Enqueue.vtt

  6. S06 - L06 -- CIRCULAR QUEUE(Array) - Dequeue.vtt

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

  8. S06 - L08 -- LINEAR QUEUE(LL) - Enqueue.mp4

  9. S06 - L09 -- LINEAR QUEUE(LL) - DeQueue.mp4

 8. S08.01 -- Binary Tree

  1. S08.01 - L01 -- What is Tree.vtt

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

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

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

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

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

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

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

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

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

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

  2. S08.01 - L02 -- Why learn Tree.vtt

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

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

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

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

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

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

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

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

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

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

  6. S08.01 - L05 -- Types of Binary Tree.mp4

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

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

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

 9. S08.02 -- Binary Search Tree (BST)

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

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

  3. S08.02 - L03 -- Traversing a BST.vtt

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

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

  6. S08.02 - L06 -- Deleting a BST.vtt

 [FreeCourseLab.com].url