Namaste DSA: Data Structures & Algorithms Course

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

Learn looping constructs to repeat code effectivelyasdg.

Count the number of digits in an integer.

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.

Learn the basics of Binary Search Trees.

Check if a tree is a valid BST.

Search for a value in a Binary Search Tree.

Insert a new node in a BST.

Find the kth smallest element in BST.

Find the lowest common ancestor in a Binary Search Tree.

Understand the fundamentals of Heaps.

Learn how to build a heap from an array.

Insert an element into a heap and maintain the heap property.

Remove the root and restore heap order.

Understand the Heap Sort algorithm step-by-step.

Implement Heap Sort in code.

Explore advanced insights into Heap Sort.

Learn how priority queues work using heaps.

Implement a priority queue in code.

Find the kth largest element using a heap.

Maintain the kth largest value as numbers stream in.

Simulate a stone smashing game using heaps.

Find the k most frequent elements in an array.

Find the kth smallest element in a sorted matrix.

Detect cycles in a Linked List using extra space.

Check if a Linked List is a palindrome.

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

Remove consecutive duplicates from a sorted Linked List.

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.

Check palindrome by cleaning and reversing a string.

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.

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

Solve Two Sum with a sorted array using two pointers.

Locate the first occurrence of a substring in a string.

Efficient substring search using the KMP algorithm.

Check if one string contains a permutation of another.

Find the longest substring with all unique characters.

Find the max value in every window of size k.

Understand the core concept of backtracking.

Generate all subsets of a set.

Find all combinations of numbers.

Generate all permutations of a list.

Subsets with duplicate elements.

Find all combinations that sum to a target.

Combination sum with single-use elements.

Find k numbers that sum to n.

Generate letter combinations from digits.

Unique permutations with duplicates.

Partition a string into palindromes.

Search a word in a grid.

Place queens safely on a chessboard.

Learn the basics of the Greedy Algorithm technique with simple examples.

Solve the classic Two City Scheduling problem using a greedy approach.

Understand how to maximize content children by assigning cookies efficiently.

Learn how to apply greedy techniques to manage change in the Lemonade Stand problem.

Master stock trading with multiple transactions using greedy techniques.

Learn how to insert a new interval into a set of non-overlapping intervals.

Understand how to merge overlapping intervals into non-overlapping ones.

Split a string into partitions where each character appears in at most one part.

Find the minimum number of intervals to remove to avoid overlaps.

Schedule tasks efficiently with cooldown periods using greedy + heaps.

Learn how to find the starting gas station index to complete a circuit.

Check if carpooling is possible given trips and capacity.

Distribute candies fairly using a two-pass O(n) approach.

Distribute candies fairly using a two-pass O(n) approach.

Understand the basics of Dynamic Programming and its importance.

Solve Fibonacci efficiently with Dynamic Programming.

Compare top-down and bottom-up DP techniques.

Learn how to solve the classic Climbing Stairs DP problem.

Solve minimum cost climbing stairs with DP.

Maximize robbery amount without robbing adjacent houses.

Solve House Robber II with circular houses constraint using DP.

Learn recursive top-down DP for the Coin Change problem.

Solve Coin Change with bottom-up DP using iteration.

Count palindromic substrings using DP.

Find the longest palindromic substring with DP.

Solve Decode Ways problem with recursion and DP.

Find maximum subarray sum using Kadane’s Algorithm.

Solve Maximum Product Subarray with DP approach 1.

Optimize Maximum Product Subarray with approach 2.

Solve the classic Word Break problem by checking if a given string can be segmented into valid words from a dictionary

Solve the Longest Increasing Subsequence problem by finding the length of the longest strictly increasing sequence in an array.

Tackle the Partition Equal Subset Sum problem by checking if an array can be split into two subsets with the same total sum.

Solve the Coin Change II problem by finding how many ways you can make a given amount using an unlimited supply of coins

Solve the Unique Paths problem by finding the total number of ways to move from the top-left to the bottom-right of a grid.

Understand what graphs are and why they matter in DSA.

Learn the Breadth First Search (BFS) algorithm step by step.

Master the Depth First Search (DFS) algorithm for graphs.

Check if a path exists between two nodes using BFS.

Implement Depth First Search recursively in graphs.

Find all possible paths from source to target using DFS.

Rebuild an itinerary using graph traversal.

Detect if a cycle exists in an undirected graph.

Perform Topological Sorting using DFS.

Learn Kahn’s Algorithm for Topological Sorting using BFS.

Overview of shortest path algorithms in graphs.

Find the shortest path in an unweighted graph using BFS.

Understand Dijkstra’s Algorithm for weighted graphs.

Implement Dijkstra’s Algorithm in code.

Find shortest paths with negative weights using Bellman-Ford.

Code the Bellman-Ford Algorithm step by step.

Understand the Floyd-Warshall Algorithm for all-pairs shortest paths.

Implement the Floyd-Warshall Algorithm step by step in code.

Compare Dijkstra, Bellman-Ford, and Floyd-Warshall algorithms.

Understand the concept of a Minimum Spanning Tree (MST).

Learn Prim’s Algorithm for building MSTs.

Implement Prim’s Algorithm in code.

Learn the Union-Find data structure for efficient set merging.

Understand Kruskal’s Algorithm for MST construction.

Implement Kruskal’s Algorithm using Union-Find.

Compare Prim’s and Kruskal’s MST algorithms.

Find the minimum operations to connect all computers in a network.

Find the cheapest flight within a limited number of stops.

Count the number of shortest paths to reach the destination.

Connect all points with minimum total cost.

Understand the fundamental concept and purpose of a Trie data structure.

Design the TrieNode class and the overall Trie structure.

Implement the core operations: Insert, Search, and StartsWith.

Analyze the efficiency of Trie operations and their memory footprint.

Learn how Quick Sort works using divide and conquer.

Understand the basics of Counting Sort.

Learn the logic behind stable Counting Sort.

Implement stable Counting Sort in code.

Sort numbers digit by digit using Radix Sort.

Distribute elements into buckets for efficient sorting.

Quick revision guide for sorting and DSA interviews.

Salary Negotiation Masterclass

Resume Masterclass

Personal Branding Masterclass

LinkedIn Masterclass

Remove specific elements from an array.

Reverse the characters of a string.

Sort an array using the insertion sort algorithm.