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