1. Урок 1.00:07:09
    S01 - L01 -- Course Breakdown
  2. Урок 2.00:04:37
    S01 - L02 -- What is DS and Algo
  3. Урок 3.00:03:28
    S01 - L03 -- Why companies ask DS
  4. Урок 4.00:03:30
    S01 - L04 -- DS in every day life
  5. Урок 5.00:03:42
    S01 - L05 -- Types of DS
  6. Урок 6.00:11:59
    S01.1-L01--What is Recursion
  7. Урок 7.00:05:07
    S01.1-L02--Why learn Recursion
  8. Урок 8.00:04:09
    S01.1-L03--Format of Recursion Method
  9. Урок 9.00:14:41
    S01.1-L04--How Recurssion works internally
  10. Урок 10.00:08:22
    S01.1-L05--Finding Factorial using Recursion
  11. Урок 11.00:07:42
    S01.1-L06--Finding Fibonacci using Recursion
  12. Урок 12.00:03:19
    S01.1-L07--Recursion vs Iteration
  13. Урок 13.00:04:43
    S01.1-L08--When to Use & Avoid Recursion
  14. Урок 14.00:03:16
    S01.1-L09--Practical Uses of Recursion
  15. Урок 15.00:03:14
    S02-L01 -- What is Algo Run Time Analysis
  16. Урок 16.00:10:39
    S02-L02 -- What are Notations
  17. Урок 17.00:07:55
    S02-L03 -- Examples of Notations
  18. Урок 18.00:06:52
    S02-L04 -- Examples of Time Complexity
  19. Урок 19.00:08:14
    S02-L05 -- Finding Time Complexity of Iterative Algo
  20. Урок 20.00:11:10
    S02-L06 -- Finding Time Complexity of Recursive Algo#1
  21. Урок 21.00:17:48
    S02-L07 -- Finding Time Complexity of Recursive Algo#2
  22. Урок 22.00:07:02
    S03 - L01 -- What and Why of Array
  23. Урок 23.00:07:18
    S03 - L02 -- Types of Array
  24. Урок 24.00:06:01
    S03 - L03 -- How is Array represented in Memory
  25. Урок 25.00:11:26
    S03 - L04 -- Create an Array
  26. Урок 26.00:07:05
    S03 - L05 -- Insert Traverse in 1D Array
  27. Урок 27.00:16:27
    S03 - L06 -- Access Search Delete in 1D Array
  28. Урок 28.00:13:45
    S03 - L07 -- Code 1D Array
  29. Урок 29.00:04:02
    S03 - L08 -- Time Complexity of 1D Array
  30. Урок 30.00:09:14
    S03 - L09 -- Create 2D Array
  31. Урок 31.00:14:49
    S03 - L10 -- 2D Array operations
  32. Урок 32.00:02:56
    S03 - L11 -- Time Complexity of 2D Array
  33. Урок 33.00:06:17
    S03 - L12 -- When to use Array
  34. Урок 34.00:14:33
    S03 - L13 -- Code 2D Array
  35. Урок 35.00:07:31
    S03 - L14 -- Practical uses of Array
  36. Урок 36.00:08:44
    S04 - L01 -- What is linked list
  37. Урок 37.00:03:19
    S04 - L02 -- Linked list vs Array
  38. Урок 38.00:06:30
    S04 - L03 -- Components of LinkedList
  39. Урок 39.00:06:55
    S04 - L04 -- Types of LinkedList
  40. Урок 40.00:07:57
    S04 - L05 -- Why so many types of LinkedList
  41. Урок 41.00:05:06
    S04 - L06 -- How is LinkedList stored in Memory
  42. Урок 42.00:05:57
    S04 - L07 -- Creation of Single LinkedList (SLL)
  43. Урок 43.00:07:24
    S04 - L08 -- Insertion in SLL - Dry Run
  44. Урок 44.00:10:57
    S04 - L09 -- Insertion in SLL - Algo
  45. Урок 45.00:03:50
    S04 - L10 -- Traversal of SLL
  46. Урок 46.00:04:53
    S04 - L11 -- Search node in SLL
  47. Урок 47.00:09:14
    S04 - L12 -- Deletion of node from SLL - Dry Run
  48. Урок 48.00:08:48
    S04 - L13 -- Deletion of node from SLL - Algo
  49. Урок 49.00:03:15
    S04 - L14 -- Delete entire SLL
  50. Урок 50.00:03:30
    S04 - L15 -- Time Complexity of SLL
  51. Урок 51.00:04:07
    S04 - L16 -- Creation of Circular Single LinkedList (CSLL)
  52. Урок 52.00:06:16
    S04 - L17 -- Insertion of data in CSLL - Dry Run
  53. Урок 53.00:07:45
    S04 - L18 -- Insertion of data in CSLL - Algo
  54. Урок 54.00:02:31
    S04 - L19 -- Traverse CSLL
  55. Урок 55.00:04:54
    S04 - L20 -- Search a node in CSLL
  56. Урок 56.00:05:35
    S04 - L21 -- Delete a node from CSLL - Dry Run
  57. Урок 57.00:07:05
    S04 - L22 -- Deletion of node from CSLL - Algo
  58. Урок 58.00:04:02
    S04 - L23 -- Deletion of entire CSLL
  59. Урок 59.00:04:17
    S04 - L24 -- Time Complexity of CSLL
  60. Урок 60.00:05:59
    S04 - L25 -- Create Double Linked List (DLL)
  61. Урок 61.00:08:00
    S04 - L26 -- Insert node in DLL - Dry Run
  62. Урок 62.00:13:35
    S04 - L27 -- Insert node in DLL - Algo
  63. Урок 63.00:02:32
    S04 - L28 -- Traverse DLL
  64. Урок 64.00:03:21
    S04 - L29 -- Reverse Traversal of DLL
  65. Урок 65.00:03:13
    S04 - L30 -- Search a node in DLL
  66. Урок 66.00:07:21
    S04 - L31 -- Delete a node from DLL - Dry Run
  67. Урок 67.00:09:40
    S04 - L32 -- Delete a node from DLL - Algo
  68. Урок 68.00:04:47
    S04 - L33 -- Delete entire DLL
  69. Урок 69.00:04:13
    S04 - L34 -- Time Complexity of DLL
  70. Урок 70.00:07:37
    S04 - L35 -- Create Double Circular LinkedList (CDLL)
  71. Урок 71.00:11:06
    S04 - L36 -- Insert node in CDLL - Dry Run
  72. Урок 72.00:09:46
    S04 - L37 -- Insert node in CDLL - Algo
  73. Урок 73.00:03:36
    S04 - L38 -- Traverse CDLL
  74. Урок 74.00:03:28
    S04 - L39 -- Reverse traverse CDLL
  75. Урок 75.00:04:31
    S04 - L40 -- Search a node in CDLL
  76. Урок 76.00:08:45
    S04 - L41 -- Delete a node from CDLL - Dry Run
  77. Урок 77.00:10:38
    S04 - L42 -- Delete a node from CDLL - Algo
  78. Урок 78.00:06:29
    S04 - L43 -- Delete entire CDLL
  79. Урок 79.00:04:27
    S04 - L44 -- Time Complexity of CDLL
  80. Урок 80.00:06:43
    S04 - L45 -- SLL vs CSLL vs DLL vs DLL
  81. Урок 81.00:05:10
    S04 - L46 -- Practical uses of LinkedList
  82. Урок 82.00:04:55
    L01 -- What and Why of Stack
  83. Урок 83.00:06:19
    L02 -- ARRAY - Create & Push
  84. Урок 84.00:07:52
    L03 -- ARRAY - Pop, Peek, isEmpty, isFull, Delete
  85. Урок 85.00:06:36
    L04 -- LinkedList - Create, Push, Pop
  86. Урок 86.00:05:06
    L05 -- LinkedList - Peek, Delete
  87. Урок 87.00:03:36
    L06 -- When to use or avoid Stack
  88. Урок 88.00:03:53
    S06 - L01 -- What and Why of Queue
  89. Урок 89.00:06:59
    S06 - L02 -- LINEAR QUEUE(Array) - Create, Enqueue
  90. Урок 90.00:07:23
    S06 - L03 -- LINEAR QUEUE((Array)) - deQueue, isEmpty, isFull, Delete
  91. Урок 91.00:04:45
    S06 - L04 -- Why Circular Queue
  92. Урок 92.00:05:57
    S06 - L05 -- CIRCULAR QUEUE(Array) - Enqueue
  93. Урок 93.00:03:19
    S06 - L06 -- CIRCULAR QUEUE(Array) - Dequeue
  94. Урок 94.00:05:22
    S06 - L07 -- CIRCULAR QUEUE(Array) - Peek, isEmpty, isFull, Delete
  95. Урок 95.00:05:31
    S06 - L08 -- LINEAR QUEUE(LL) - Enqueue
  96. Урок 96.00:03:11
    S06 - L09 -- LINEAR QUEUE(LL) - DeQueue
  97. Урок 97.00:04:04
    S06 - L10 -- LINEAR QUEUE(LL) - Peek, isEmpty, Delete
  98. Урок 98.00:04:29
    S06 - L11 -- Array vs LinkedList Implementation
  99. Урок 99.00:09:30
    S08.01 - L01 -- What is Tree
  100. Урок 100.00:02:08
    S08.01 - L02 -- Why learn Tree
  101. Урок 101.00:10:01
    S08.01 - L03 -- Tree Terminologies - Part#1
  102. Урок 102.00:04:29
    S08.01 - L03 -- Tree Terminologies - Part#2
  103. Урок 103.00:04:15
    S08.01 - L04 -- What & Why of Binary Ttree
  104. Урок 104.00:05:29
    S08.01 - L05 -- Types of Binary Tree
  105. Урок 105.00:08:54
    S08.01 - L06 -- How is Tree Represented in Code
  106. Урок 106.00:03:17
    S08.01 - L07 -- Create blank Binary Tree(LL)
  107. Урок 107.00:14:45
    S08.01 - L08 -- Pre-order traversal Binary Tree(LL)
  108. Урок 108.00:06:18
    S08.01 - L09 -- In-order traversal Binary Tree(LL)
  109. Урок 109.00:06:33
    S08.01 - L10 -- Post-order traversal Binary Tree(LL)
  110. Урок 110.00:07:26
    S08.01 - L11 -- Level-order traversal Binary Tree(LL)
  111. Урок 111.00:08:10
    S08.01 - L12 -- Search for value in Binary Tree(LL)
  112. Урок 112.00:05:54
    S08.01 - L13 -- Insert value in Binary Tree(LL)
  113. Урок 113.00:06:55
    S08.01 - L14 -- Delete value from Binary Tree(LL)
  114. Урок 114.00:03:59
    S08.01 - L15 -- Delete Binary Tree(LL)
  115. Урок 115.00:05:14
    S08.01 - L16 -- Create Binary Tree(Array)
  116. Урок 116.00:05:55
    S08.01 - L17 -- Insert value in Binary Tree(Array)
  117. Урок 117.00:03:39
    S08.01 - L18 -- Search for value in Binary Tree(Array)
  118. Урок 118.00:06:18
    S08.01 - L19 -- Inorder traversal of Binary Tree(Array)
  119. Урок 119.00:03:48
    S08.01 - L20 -- Pre-order traversal of Binary Tree(Array)
  120. Урок 120.00:04:18
    S08.01 - L21 -- Post-order traversal of Binary Tree(Array)
  121. Урок 121.00:02:46
    S08.01 - L22 -- Level-order traversal of Binary Tree(Array)
  122. Урок 122.00:05:34
    S08.01 - L23 -- Delete node from Binary Tree(Array)
  123. Урок 123.00:03:26
    S08.01 - L24 -- Delete Binary Tree(Array)
  124. Урок 124.00:04:44
    S08.01 - L25 -- Binary Tree (Array vs Linked List)
  125. Урок 125.00:04:45
    S08.02 - L01 -- What & Why of BST
  126. Урок 126.00:10:00
    S08.02 - L02 -- Creation & Searching in BST
  127. Урок 127.00:07:37
    S08.02 - L03 -- Traversing a BST
  128. Урок 128.00:13:58
    S08.02 - L04 -- Inserting a node in BST
  129. Урок 129.00:15:55
    S08.02 - L05 -- Deleting a node from BST
  130. Урок 130.00:03:43
    S08.02 - L06 -- Deleting a BST
  131. Урок 131.00:06:49
    S08.03 - L01 -- Why learn AVL Tree
  132. Урок 132.00:10:21
    S08.03 - L02 -- What is AVL Tree
  133. Урок 133.00:06:28
    S08.03 - L03 -- Create Search Traverse AVL Tree
  134. Урок 134.00:12:02
    S08.03 - L04 -- Insert in AVL_LL Theory
  135. Урок 135.00:04:48
    S08.03 - L05 -- Insert in AVL_LL Algorithm
  136. Урок 136.00:08:13
    S08.03 - L06 -- Insert in AVL LR
  137. Урок 137.00:08:24
    S08.03 - L07 -- Insert in AVL RR
  138. Урок 138.00:06:23
    S08.03 - L08 -- Insert in AVL RL
  139. Урок 139.00:14:20
    S08.03 - L09 -- Insert End to End Case
  140. Урок 140.00:11:27
    S08.03 - L10 -- Delete LL LR RR RL
  141. Урок 141.00:11:57
    S08.03 - L11 -- Delete End to End Case
  142. Урок 142.00:07:37
    S08.03 - L12 -- Delete AVL Tree & Tree Comparison
  143. Урок 143.00:12:27
    S08.04 - L01 -- What Why and Type of Heap
  144. Урок 144.00:04:45
    S08.04 - L02 -- Create, Peek, Size of Heap
  145. Урок 145.00:05:12
    S08.04 - L03 -- Insert element in Heap
  146. Урок 146.00:06:04
    S08.04 - L04 -- Extract and Delete from Heap
  147. Урок 147.00:03:50
    S08.04 - L05 -- Why avoid Reference based implementation ?
  148. Урок 148.00:05:57
    S08.05 - L01 -- What and Why of Trie
  149. Урок 149.00:06:53
    S08.05 - L02 -- Create Insert in Trie
  150. Урок 150.00:02:36
    S08.05 - L03 -- Search a String in Trie
  151. Урок 151.00:07:38
    S08.05 - L04 -- Delete a String from Trie
  152. Урок 152.00:02:33
    S08.05 - L05 -- Practical Uses of Trie
  153. Урок 153.00:03:39
    S09 - L01 -- Introduction to Hashing
  154. Урок 154.00:05:13
    S09 - L02 -- Why learn Hashing ?
  155. Урок 155.00:08:53
    S09 - L03 -- Introduction to Hash Functions
  156. Урок 156.00:14:55
    S09 - L04 -- Types of Collision Resolution Techniques
  157. Урок 157.00:04:31
    S09 - L05 -- What happens when Hash Table is full ?
  158. Урок 158.00:08:27
    S09 - L06 -- Collision Resolution Techniques Compared
  159. Урок 159.00:06:41
    S09 - L07 -- Practical Use of Hashing
  160. Урок 160.00:04:37
    S09 - L08 -- Hashing vs Other DS
  161. Урок 161.00:03:55
    S10 - L01 -- What and Why of Sorting
  162. Урок 162.00:07:15
    S10 - L02 -- Types of Sorting Techniques
  163. Урок 163.00:05:02
    S10 - L03 -- Sorting Terminologies
  164. Урок 164.00:07:47
    S10 - L04 -- Bubble Sort
  165. Урок 165.00:06:08
    S10 - L05 -- Selection Sort
  166. Урок 166.00:08:52
    S10 - L06 -- Insertion Sort
  167. Урок 167.00:08:35
    S10 - L07 -- Bucket Sort
  168. Урок 168.00:11:12
    S10 - L08 -- Merge Sort
  169. Урок 169.00:12:37
    S10 - L09 -- Quick Sort Part#1
  170. Урок 170.00:06:01
    S10 - L09 -- Quick Sort Part#2
  171. Урок 171.00:12:42
    S10 - L10 -- HeapSort
  172. Урок 172.00:02:15
    S10 - L11 -- Sorting Techniques compared
  173. Урок 173.00:08:57
    S11 - L01 -- What and Why of Graphs
  174. Урок 174.00:05:12
    S11 - L02 -- Graph Terminologies
  175. Урок 175.00:04:00
    S11 - L03 -- Types of Graphs
  176. Урок 176.00:07:09
    S11 - L04 -- Graph Representation in Code
  177. Урок 177.00:08:30
    S11 - L05 -- BFS Algorithm
  178. Урок 178.00:06:34
    S11 - L06 -- BFS Time Complexity
  179. Урок 179.00:08:08
    S11 - L07 -- DFS Algorithm
  180. Урок 180.00:05:59
    S11 - L08 -- DFS Time Complexity
  181. Урок 181.00:04:27
    S11 - L09 -- BFS vs DFS
  182. Урок 182.00:03:45
    S11 - L10 -- What is Topological Sort
  183. Урок 183.00:06:33
    S11 - L11 -- Topological Sort Dry Run
  184. Урок 184.00:07:12
    S11 - L12 -- Why Topological Sort Works
  185. Урок 185.00:06:39
    S11 - L13 -- Topological Sort Algorithm
  186. Урок 186.00:06:30
    S11 - L14 -- What is Single Source Shortest Path Problem(SSSP)
  187. Урок 187.00:08:08
    S11 - L15 -- BFS for SSSP
  188. Урок 188.00:04:04
    S11 - L16 -- Why BFS does not works for Weighted Graph SSSP
  189. Урок 189.00:03:02
    S11 - L17 -- Why DFS does not works for SSSP
  190. Урок 190.00:11:17
    S11 - L18 -- Dijkstra for SSSP
  191. Урок 191.00:06:07
    S11 - L19 -- Why Dijkstra does not work for Negative Cycle
  192. Урок 192.00:09:48
    S11 - L20 -- BellmanFord Dry run for SSSP
  193. Урок 193.00:04:28
    S11 - L21 -- BellanFord Algorithm for SSSP
  194. Урок 194.00:09:09
    S11 - L22 -- How Bellman Ford works for Negative Cycle
  195. Урок 195.00:10:09
    S11 - L23 -- Why BellmanFord runs for V-1 times
  196. Урок 196.00:04:33
    S11 - L24 -- BFS vs Dijkstra vs BellmanFord
  197. Урок 197.00:05:35
    S11 - L25 -- What is All Pair Shortest Path Problem(APSP)
  198. Урок 198.00:05:18
    S11 - L26 -- Dry run of BFS Dijkstra Bellman for APSP
  199. Урок 199.00:10:09
    S11 - L27 -- Floyd Warshall Algorithm for APSP
  200. Урок 200.00:08:13
    S11 - L28 -- Why Floyd Warshall Algorithm always works
  201. Урок 201.00:03:50
    S11 - L29 -- Why Floyd does not works for Negative Cycle
  202. Урок 202.00:04:25
    S11 - L30 -- BFS vs Dijkstra vs Bellman vs Floys
  203. Урок 203.00:04:39
    S11 - L31 -- What is Minimum Spanning Tree (MST)
  204. Урок 204.00:08:49
    S11 - L32.1 -- DisjointSet
  205. Урок 205.00:12:40
    S11 - L32.2 -- Kruskals Algorithm
  206. Урок 206.00:06:34
    S11 - L33 -- Prims Algorithm Dry Run
  207. Урок 207.00:05:23
    S11 - L34 -- Prims Algorithm Explained
  208. Урок 208.00:02:34
    S11 - L35 -- Prims vs Kruskal
  209. Урок 209.00:04:46
    S12.1 - L01 -- Magic Framework
  210. Урок 210.00:06:18
    S12.2 - L01 -- Greedy Algo Introduction
  211. Урок 211.00:10:51
    S12.2 - L02 -- Known Algos
  212. Урок 212.00:08:05
    S12.2 - L03 -- Activity Selection Problem
  213. Урок 213.00:09:07
    S12.2 - L04 -- Coin Change Problem
  214. Урок 214.00:11:56
    S12.2 - L05 -- Fractional Knapsack Problem
  215. Урок 215.00:07:35
    S12.3 - L01 -- What and Why of Divide&Conquer
  216. Урок 216.00:05:48
    S12.3 - L02 -- Binary Search, Quick, Merge Sortt
  217. Урок 217.00:03:32
    S12.3 - L03 -- Fibonacci Series
  218. Урок 218.00:09:38
    S12.3 - L04 -- Number Factor
  219. Урок 219.00:08:49
    S12.3 - L05 -- House thief
  220. Урок 220.00:12:58
    S12.3 - L06 -- Convert One String to Another
  221. Урок 221.00:07:49
    S12.3 - L07 -- Zero-One Knapsack
  222. Урок 222.00:08:52
    S12.3 - L08 -- Longest Common Subsequence
  223. Урок 223.00:09:47
    S12.3 - L09 -- Longest Palindromic Subsequence
  224. Урок 224.00:09:11
    S12.3 - L10 -- Longest Palindromic Substring
  225. Урок 225.00:07:13
    S12.3 - L11 -- Min Cost to Reach End of Array
  226. Урок 226.00:10:30
    S12.3 - L12 -- Number of Paths to reach last cell with given Cost
  227. Урок 227.00:04:46
    S12.4 - L01 -- What and Why of Dynamic Programming
  228. Урок 228.00:06:41
    S12.4 - L02 -- Top Down Approach
  229. Урок 229.00:07:45
    S12.4 - L03 -- Bottom Up Approach
  230. Урок 230.00:03:57
    S12.4 - L04 -- Is Merge Sort Dynamic Programming ?
  231. Урок 231.00:15:26
    S12.4 - L05 -- Number Factor Problem
  232. Урок 232.00:12:15
    S12.4 - L06 -- HouseThief Problem
  233. Урок 233.00:11:20
    S12.4 - L07 -- Convert One String to Another
  234. Урок 234.00:13:16
    S12.4 - L08 -- Zero One Knapsack Problem
  235. Урок 235.00:10:20
    S12.4 - L09 -- Longest Common Subsequence
  236. Урок 236.00:10:53
    S12.4 - L10 -- Longest Palindromic Subsequence
  237. Урок 237.00:12:34
    S12.4 - L11 -- Longest Palindromic Substring
  238. Урок 238.00:12:35
    S12.4 - L12 -- Min Cost to Reach End of Array
  239. Урок 239.00:24:53
    S12.4 - L13 -- Ways to Reach last cell