DSA with C++: A Placement Series

Lecture 9: Introduction to Arrays in C++

1:29:54

Lecture 10: Solving LeetCode/CodeStudio Questions [Arrays]

1:34:54

Lecture 11:Time & Space Complexity || How to avoid Time Limit Exceeded [TLE]

29:12

Lecture 12: Binary Search Explained in 1 Video [Theory + Code]

38:41

Lecture 13: Binary Search Interview Questions [Google, Amazon, Microsoft] || ProblemSet - 1

41:33

Lecture14: Binary Search Interview Questions [Google, Amazon, Microsoft] || ProblemSet - 2

55:35

Lecture 15: Book Allocation Problem || Aggressive Cows Problem || Binary Search Advanced Problems

1:05:13

Lecture16: Selection Sort [Theory + Code] || C++ Placement Series

34:29

CodeHelp Weekly Contest 1 is LIVE || Game starts Now

2:13

Lecture 17: BUBBLE SORT in 1 Video [Theory + Optimised Code] || Best/Worst Case Complexity

31:52

Lecture 18: INSERTION SORT in 1 Video [Theory + Code] || Best/Worst Case Complexity

34:04

Lecture19: C++ STL in 1 Video (Re-Uploaded)

1:01:51

Lecture 20: Solving LeetCode/CodeStudio Questions [Arrays]

35:38

Lecture21: Solving LeetCode/CodeStudio Questions [Arrays]

33:32

CodeHelp Weekly Contest 2 is LIVE || Contest 1 Results announced

3:22

Lecture22: All about Char Arrays, Strings & solving LeetCode Questions

1:53:20

Lecture 23: Introduction to 2D Arrays in C++ || LeetCode Questions

1:30:36

Lecture 24: Basic Maths for DSA || Sieve || Modular Arithmetics || Euclid’s Algorithm

44:08

DSA Placement course || Phase-1 Completed

0:55

Lecture 25: Pointers in C++ || Part-1 || DSA Placement Course - Love Babbar

44:11

Lecture 26: Pointers in C++ || Part-2 || DSA Placement Course - Love Babbar

1:03:59

Lecture27: Double Pointers in C++ || Pointers Practice MCQs

52:52

Lecture28: Reference Variable | Static vs Dynamic Memory | Part-1

47:12

Lecture29: Dynamic Memory Allocation of 2D Arrays

22:53

Lecture30: Macros, Global Variables, Inline Functions & Default Args

39:23

Lecture 31: Learning Recursion the Best Way! | 10 Day Recursion Challenge

37:36

Lecture32: Understanding Recursion the easiest way || Day-2 || 10 Day Recursion Challenge

45:16

Lecture33: Recursion and Binary Search | Day-3 | 10 Days Recursion Challenge

43:14

Lecture34: Recursion with Strings | Day-4 | 10 Day Recursion Challenge

36:49

Lecture35: Merge Sort using Recursion | Day-5 | 10 Day Recursion Challenge

24:23

CodeHelp Weekly Contest 3 is LIVE || Contest 1 & 2 Gifts Sent !!

2:32

Lecture36: Quick Sort using Recursion | Day-6 | 10 Day Recursion Challenge

37:55

Lecture37: Recursion - Subsets / Subsequences of String [Theory + Code]

27:25

Lecture38: Phone Keypad Problem Recursion || C++ Placement Course

30:42

Lecture39: Permutations of a String || C++ Placement Course

21:50

Lecture40: Rat in a Maze Problem || C++ Placement Course 2022

37:31

Lecture 41: Time & Space Complexity of Recursive Algorithms || C++ Placement Course

49:23

Lecture 42: OOPs Concepts in C++ || Part-1

1:29:14

Lecture 43 : 4 Pillars of OOPs Concept -Inheritance, Polymorphism, Encapsulation & Abstraction

1:35:29

Lecture 44: Linked List & its types - Singly, Doubly, Circular etc.

2:21:18

Lecture 45: Linked List Questions: Reverse LL and find Middle of LL

52:40

CodeHelp Weekly Contest 4 is LIVE || Contest Editorial/Solutions

3:35

Lecture 46: Linked List Questions: Reverse LL in "K group" && Check LL is Circular or not

40:08

Lecture47: Detect & Remove Loop in Linked List [Approach Discussion + Optimised Implementation]

50:36

Lecture 48: Remove Duplicates from a Sorted/UnSorted Linked List

27:25

Lecture 49: Merge 2 Sorted Linked Lists || Sort 0s, 1s and 2s in Linked List

58:44

Lecture 50: Check Palindrome in Linked List || C++ Placement Course

22:38

Lecture 51: Add 2 Numbers represented by Linked Lists || C++ Placement Course

26:24

Lecture 52: Clone a Linked List with Random Pointers || C++ Placement Course

55:08

Lecture 53: Merge Sort in Linked List [ Theory + Implementation ]

27:49

Lecture 54: Introduction to Stacks [Theory + Implementation] || C++ Placement Course

43:11

Lecture 55: Stack Interview Questions || Placement Series by Love Babbar

1:35:53

Lecture 56: Largest Rectangular Area in Histogram [Optimised Approach]

28:31

Lecture 57: Stack - Celebrity Problem && Max Rectangle in Binary Matrix with all 1's

43:54

Lecture 58: "N" Stacks in an Array || Stack Hard Question

37:48

Lecture 59: Design Special Stack Problem || C++ Placement Course

29:29

Lecture 60: Queues in C++ [STL + Implementation + Types of Queues ]

1:05:02

Lecture 61: Queue FAANG Interview Questions || Placement Series by Love Babbar

2:23:55

Lecture 62: Binary Trees & its Representation || Different types of Traversals

55:06

CodeHelp Weekly Contest 5 is LIVE || Contest Editorial/Solutions

2:24

Lecture 63: Binary Tree FAANG Interview Questions || Part-1

1:01:05

Lecture 64: Binary Tree FAANG Interview Questions || Part-2

1:11:31

Lecture 65: Binary Tree FAANG Interview Questions || Part-3

59:15

Lecture 66: Construct a Binary Tree from InOrder/PreOrder/PostOrder Traversal

36:35

Lecture 67: Minimum Time to BURN the Entire Binary Tree || C++ Placement Series

28:28

Lecture 68: Morris Traversal || Flatten a Binary tree to Linked List || C++ Placement Series

31:54

Lecture 69: Binary Search Tree & its Implementation || Insertion, Deletion & Searching a Node

1:05:47

Lecture 70: Binary SearchTree FAANG Interview Questions || Part-1

37:55

Lecture 71: Binary SearchTree FAANG Interview Questions || Part-2

48:19

Lecture 72: Merge 2 Binary Search Trees || C++ Placement Series

45:58

Lecture 73: Largest BST in a Binary Tree || C++ Placement Series

23:09

Lecture 74: Heaps in C++ || Heap Sort || Insertion/Deletion in Heap || Priority Queue STL

1:04:56

Lecture 75: Heaps in C++ || Interview Questions || Part - 1

1:08:00

CodeHelp Weekly Contest 6 is LIVE || MacBook Giveaway Coming Soon

2:51

Lecture 76: Heaps in C++ || Interview Questions || Part - 2

50:01

Lecture 77: Heaps Hard Interview Questions || Part - 3

1:05:15

Lecture 78: Hashmaps in C++ || C++ Placement Series

1:03:27

CodeHelp Weekly Contest 7 is LIVE

1:20

Lecture 79: Trie & its Implementation || C++ Placement Series

48:20

Lecture 80: Longest Common Prefix Problem || Tries || C++ Placement Series

20:17

Lecture 81: Implement a Phone Directory Using Trie || C++ Placement Series

27:04

Lecture 82: Rat in Maze Problem || Backtracking Day 1 || C++ Placement Series

31:37

Lecture 83: N-Queen Problem || Backtracking Day 2 || C++ Placement Series

31:04

Lecture 84: Sudoku Solver Problem || Backtracking Day 3 || C++ Placement Series

23:10

Lecture 85: Introduction to Graphs || Creation and Implementation

33:29

Lecture 86: BFS Traversal in Graph || C++ Placement Series

23:39

Lecture 87: DFS Traversal in Graph || C++ Placement Series

14:18

Lecture 88: Cycle Detection in Undirected Graphs || Using BFS and DFS

32:03

Lecture 89: Cycle Detection in Directed Graphs || Placement Series

18:30

Lecture 90: Topological Sort ( Using DFS ) || Placement Series

20:09

Lecture 91: Topological Sort ( Using Kahn's Algorithm ) || Placement Series

17:02

CodeHelp Weekly Contest 9 is LIVE || C++ Placement Series

2:35

Lecture 92: Cycle Detection in Directed Graph || Using BFS

8:23

Lecture 93: Shortest Path in Undirected Graphs || C++ Placement Series

19:53

Lecture 94: Shortest Path in Directed Acyclic Graphs || C++ Placement Series

34:09

Lecture 95: Dijkstra's Algorithm || C++ Placement Series

35:55

Lecture 96: Minimum Spanning Tree || Prim's Algorithm

33:04

Lecture 97: Kruskal's Algorithm || Disjoint Set || Union by Rank & Path Compression

40:31

Lecture 98: Bridges in a Graph || C++ Placement Series

25:13

Lecture 99: Articulation Points in Graphs || C++ Placement Series

29:52

Lecture 100: Kosaraju's Algorithm for Strongly Connected Components || C++ Placement Series

21:43

Lecture 101: Bellman Ford Algorithm || C++ Placement Series

22:06

Lecture 102: Introduction to Dynamic Programming | Memoization | Tabulation | Space Optimisation

37:21

Lecture 103: Minimum Cost Climbing Stairs || DP Series

34:28

Lecture 104: Minimum Number of Coins || DP Series

30:36

Lecture 105: Maximum Sum of Non-Adjacent Elements || DP Series

20:33

Lecture 106: House Robbery Problem || DP Series

11:33

Lecture 107: Cut Rod into Segments of X, Y, Z || DP Series

24:39

Lecture 108: Count derangements || DP Series

26:35

Lecture 109: Painting Fence Algorithm || DP Series

25:03

Lecture 110: 0/1 KnapSack Problem || learn 2-D DP Concept || DP Series

51:19

Lecture 111: Combination Sum IV Problem || DP Series

17:45

Lecture 112: Perfect Squares Problem || DP Series

20:38

Lecture 113: Minimum Cost for Tickets || Part-1 || DP Series

26:17

Lecture 114: Minimum Cost for Tickets || Part-2 || DP Series

17:45

Lecture 115: Largest Square area in Matrix || DP Series

27:31

Lecture 116: Min Score Triangulation of Polygon || DP Series

26:08

Lecture 117: Minimum Sideways Jump LeetCode || 2D-DP || DP Series

50:31

Lecture 118: Reducing Dishes LeetCode || 2D-DP || DP Series

27:27

Lecture 119: Longest Increasing Subsequence + Russian Doll LeetCode || DP + Binary Search

46:24

Lecture 120: Maximum Height by Stacking Cuboid || DP Series

16:10

Lecture 121: Pizza with 3n Slices || 2D - DP || DP Series

27:31

Lecture 122: Number of Dice Rolls with Target Sum || DP Series

33:19

Lecture 123: Partition Equal Subset Sum || DP Series

27:59

Lecture 124: Minimum Swaps to make Subsequences Increasing || DP Series

42:10

Lecture 125: Longest Arithmetic Subsequence || DP Series

37:42

Lecture 126: Longest AP with given Difference "d" || DP Series

11:24

Lecture 127: Unique Binary Search Trees || Catalan Number

20:27

Lecture 128: Guess Number Higher or Lower || DP Series

25:03

Lecture 129: Minimum Cost Tree From Leaf Values || DP Series

26:49

Lecture 130: Buy and Sell Stock [Part 1] || DP Series

9:50

Lecture 131: Buy and Sell Stock [Part 2] || DP Series

30:05

Lecture 132: Buy and Sell Stock [Part 3] || DP Series

20:59

Lecture 133: Buy and Sell Stock [Part 4] || DP Series

18:30

Lecture 134: Buy and Sell Stock [Part 5] || DP Series

8:26

Lecture 135: Longest Common Subsequence || DP on Strings

22:07

Lecture 136: Longest Palindromic Subsequence || DP on Strings

8:25

Lecture 137: EDIT Distance || DP on Strings

30:03

Lecture 138: Maximum Rectangle with all 1's || DP Series

13:07

Lecture 139: Wildcard Pattern Matching || DP Series

31:35

Lecture 140: GREEDY ALGORITHMS in 1 VIDEO

1:29:51