Namaste DSA 🚀

Learn how to navigate the course and what you’ll cover.

Learn how to choose your preferred programming language for the course.

Warm-up session for diving into DSA concepts.

Learn the basics of programming with simple concepts explained clearly.

Master functions and conditional logic with if-else statements.

Learn looping constructs to repeat code effectively.

Deep dive into advanced loop techniques and nested loops.

Find the second largest number in an array efficiently.

Learn how to implement nested loops for complex patterns.

Draw star patterns using nested loops for practice.

Count the number of digits in an integer.

Check if a string or number is a palindrome.

Reverse the digits of an integer programmatically.

Understand how to analyze code performance using time complexity.

Remove duplicate elements from a sorted array.

Remove specific elements from an array.

Reverse the characters of a string.

Maximize profit from stock prices using smart strategy.

Merge two sorted arrays into one sorted array.

Move all zeros to the end of the array without changing order.

Find the maximum streak of 1s in a binary array.

Find the missing number in a sequence from 1 to N.

Find the unique element in an array where all others are repeated.

Understand the basics of recursion with clear explanations and examples.

Calculate the sum of the first n natural numbers using recursion.

Find the sum of all elements in an array using simple logic.

Learn how to calculate factorials using recursion.

Solve Power of Two problem with recursion and logic.

Master recursion with deep insights, patterns, and examples.

Find an element in an array using linear search.

Find an element in a sorted array using binary search.

Sort an array using the bubble sort algorithm.

Sort an array using the selection sort algorithm.

Sort an array using the insertion sort algorithm.

Learn how Merge Sort works using recursion and divide & conquer.

Get started with the basics of Linked Lists.

Learn how to design and implement your own Linked List.

Learn to insert nodes into a Linked List at various positions.

Understand node deletion in a Linked List.

Find the middle element in a Linked List efficiently.

Reverse a Linked List in-place using iteration.

Detect cycles in a Linked List using extra space.

Detect cycles with Floyd’s Tortoise & Hare algorithm.

Check if a Linked List is a palindrome.

Find the intersection node of two Linked Lists.

Remove nodes with a specific value from a Linked List.

Remove the nth node from the end using a two-pass method.

Remove the nth node from the end in one pass using two pointers.

Remove consecutive duplicates from a sorted Linked List.

Rearrange nodes based on their position (odd/even index).

Add two numbers represented as Linked Lists.

Merge two sorted Linked Lists into one.

Rotate a Linked List to the right by k places.

Swap every two adjacent nodes in a Linked List iteratively.

Recursively swap every two adjacent nodes in a Linked List.

Find the length of the last word using a basic loop approach.

Optimized one-pass solution to find the last word’s length.

Find words from a list that contain a specific character.

Count how many stones are also jewels.

Identify the most frequent vowel and consonant in a string.

Split a string into maximum balanced substrings.

Reverse parts of a string based on a pattern.

Check palindrome by cleaning and reversing a string.

Use two-pointer technique to validate palindrome.

Find the largest odd number that can be formed from a string.

Find the longest common starting substring among strings.

Check if two strings are anagrams of each other.

Check if two strings have a one-to-one character mapping.

Group words that are anagrams using sorted string keys.

Group anagrams using character frequency hash as key.

Get introduced to the fundamentals of Stacks and Queues.

Explore basic operations on stacks and queues hands-on.

Build a stack using two queues.

Implement a stack using a single queue cleverly.

Simulate a queue using two stacks.

Check if a string of parentheses is valid.

Design a stack that supports retrieving the minimum in O(1).

Remove outermost parentheses using a stack-based approach.

Remove outer parentheses without using a stack.

Evaluate mathematical expressions in postfix notation.

Find the next greater element for each number in an array.

Find how many days until a warmer temperature.

Solve the circular version of Next Greater Element.

Simulate the rotting process of oranges using BFS.

Find the square root of a number using binary search.

Learn the safe and optimal way to find the middle index.

Use binary search to guess a hidden number.

Search an element in a rotated sorted array.

Identify the first bad version using binary search.

Locate a peak element using binary search.

Find the smallest element in a rotated sorted array.

Find the first and last index of a target in a sorted array.

Optimized approach for finding first and last index of target.

Find the peak element in a mountain-shaped array.

Find the single non-duplicate element in a sorted array.

Find the k elements closest to a target in a sorted array.

Find two numbers that add up to a target using hashing.

Solve Two Sum with a sorted array using two pointers.

Check if one string is a subsequence of another.

Locate the first occurrence of a substring in a string.

Efficient substring search using the KMP algorithm.

Find the intersection node of two linked lists using two pointers.

Maximize water between two lines using two pointers.

Find all unique triplets that sum to zero.

Calculate how much water can be trapped after rain.

Find the longest substring with all unique characters.

Maximize the length of a repeating character substring.

Check if one string contains a permutation of another.

Find the max value in every window of size k.

Understand what trees are and their core properties.

Explore preorder, inorder, and postorder tree traversals.

Perform preorder traversal using recursion.

Implement inorder and postorder recursively.

Use a stack to perform preorder traversal iteratively.

Inorder traversal using a stack instead of recursion.

Use two stacks for iterative postorder traversal.

Efficient postorder traversal using just one stack.

Understand DFS vs BFS in binary trees.

Implement level order traversal using a queue.

Perform level order traversal recursively.

Find the max depth of a binary tree.

Check if a path adds up to a target sum.

Check if a binary tree is symmetric using recursion.

Check symmetry in a binary tree using BFS.

Flip a binary tree by swapping left and right nodes.

Check if two binary trees are exactly the same.

Check if a binary tree is height-balanced.

Find the longest path between any two nodes.

Traverse a binary tree in zigzag order.

Check if one binary tree is a subtree of another.

Find the lowest common ancestor of two nodes.

Print the nodes visible from the right side.

Count nodes that are greater than all previous nodes on the path.

Connect each node to its next right node in the same level.

Find the path in a tree with the maximum sum.

Salary Negotiation Masterclass

Resume Masterclass

Personal Branding Masterclass

LinkedIn Masterclass