Data Structure and Algorithms

Data Structure and Algorithms

No intro video yet

Start Date: TBA

Duration: N/A weeks

Total Seats: N/A

Seats Left: N/A

Week 1: Complexity Analysis & Arrays - Big O notation — time and space complexity - Best, worst, and average case analysis - Array fundamentals and memory layout - Two-pointer technique - Sliding window technique - Practice: subarray sums, duplicate detection Week 2: Strings & Hashing - String manipulation techniques - Hash tables — chaining vs open addressing - Sets and maps in practice - Practice: two sum, anagram grouping, frequency counting Week 3: Linked Lists - Singly and doubly linked lists - Insertion, deletion, and traversal - Reversing a linked list - Detecting and removing cycles (Floyd's algorithm) - Practice: merge two sorted lists, find middle node Week 4: Stacks & Queues - Stack and queue operations - Implementing with arrays and linked lists - Deque (double-ended queue) - Monotonic stacks - Practice: balanced parentheses, next greater element, sliding window maximum Week 5: Recursion & Backtracking - Understanding the call stack - Writing recursive solutions - Backtracking fundamentals - Practice: permutations, combinations, N-Queens, word search Week 6: Binary Search - Binary search on sorted arrays - Binary search on answer spaces - Finding boundaries (first/last position) - Practice: search in rotated array, find peak element, minimum in rotated array Week 7: Trees & Binary Trees - Tree terminology and traversals (inorder, preorder, postorder, level-order) - Height, depth, and diameter - Lowest common ancestor - Practice: validate BST, max path sum, symmetric tree Week 8: Binary Search Trees & Heaps - BST insertion, deletion, and search - Kth smallest/largest in BST - Min-heap and max-heap operations - Priority queue applications - Practice: top-K elements, median of a data stream Week 9: Graphs — Traversal & Connectivity - Adjacency list and matrix representations - Depth-first search (DFS) and breadth-first search (BFS) - Cycle detection in directed and undirected graphs - Topological sort - Union-Find (Disjoint Set Union) - Practice: number of islands, course schedule, clone graph Week 10: Graphs — Shortest Paths & Spanning Trees - Dijkstra's algorithm - Bellman-Ford algorithm - Minimum spanning tree (Kruskal's and Prim's) - Practice: network delay time, cheapest flights within K stops Week 11: Greedy & Sorting Algorithms - Merge sort and quicksort (deep dive) - Heap sort, counting sort, radix sort - Greedy strategy and when it applies - Interval problems (merge intervals, activity selection) - Practice: jump game, gas station, meeting rooms Week 12: Dynamic Programming - Memoization (top-down) and tabulation (bottom-up) - Classic 1D DP: climbing stairs, house robber, coin change - Classic 2D DP: longest common subsequence, edit distance, unique paths - 0/1 Knapsack - Practice: longest increasing subsequence, word break, partition equal subset sum

Who this course is for
  • Students actively preparing for technical interviews at product-based companies and startups
  • Computer science undergraduates who want to strengthen their algorithmic foundations
  • Self-taught developers who skipped formal data structures education and want to fill the gaps
  • Competitive programmers looking to improve problem-solving speed and accuracy
  • Software engineers targeting senior or specialist roles that require strong algorithmic skills
  • Anyone who has struggled with coding rounds and wants a structured, progressive approach to mastering DSA
What you’ll learn
  • Analyse algorithm efficiency using Big O notation for both time and space complexity
  • Implement and manipulate core data structures: arrays, strings, linked lists, stacks, queues, heaps, trees, and graphs
  • Apply the two-pointer and sliding window techniques to array and string problems
  • Use hashing and frequency maps to solve lookup and grouping problems efficiently
  • Write clean recursive solutions and apply backtracking to combinatorial problems
  • Traverse and manipulate binary trees and BSTs using DFS and BFS
  • Apply heap-based solutions and use priority queues for top-K and streaming problems
  • Represent graphs and solve traversal, connectivity, and cycle-detection problems
  • Find shortest paths using Dijkstra and Bellman-Ford algorithms
  • Design greedy solutions and recognise when a greedy approach is optimal
  • Solve dynamic programming problems using both memoization and tabulation
  • Recognise the most common interview patterns and apply them to unseen problems
  • Consistently solve medium-difficulty problems on LeetCode within time constraints
Course Structure

  • Big O notation — time and space complexity
  • Best, worst, and average case analysis
  • Array fundamentals and memory layout
  • Two-pointer technique
  • Sliding window technique
  • Practice: subarray sums, duplicate detection

  • String manipulation techniques
  • Hash tables — chaining vs open addressing
  • Sets and maps in practice
  • Practice: two sum, anagram grouping, frequency counting

  • Singly and doubly linked lists
  • Insertion, deletion, and traversal
  • Reversing a linked list
  • Detecting and removing cycles (Floyd's algorithm)
  • Practice: merge two sorted lists, find middle node

  • Stack and queue operations
  • Implementing with arrays and linked lists
  • Deque (double-ended queue)
  • Monotonic stacks
  • Practice: balanced parentheses, next greater element, sliding window maximum

  • Understanding the call stack
  • Writing clean recursive solutions
  • Backtracking fundamentals and pruning
  • Practice: permutations, combinations, N-Queens, word search

  • Binary search on sorted arrays
  • Binary search on answer spaces
  • Finding boundaries (first and last position)
  • Practice: search in rotated array, find peak element, minimum in rotated array

  • Tree terminology and traversals (inorder, preorder, postorder, level-order)
  • Height, depth, and diameter of a tree
  • Lowest common ancestor
  • Practice: validate BST, max path sum, symmetric tree

  • BST insertion, deletion, and search
  • Kth smallest and largest in BST
  • Min-heap and max-heap operations
  • Priority queue applications
  • Practice: top-K elements, median of a data stream

  • Adjacency list and matrix representations
  • Depth-first search (DFS) and breadth-first search (BFS)
  • Cycle detection in directed and undirected graphs
  • Topological sort
  • Union-Find (Disjoint Set Union)
  • Practice: number of islands, course schedule, clone graph

  • Dijkstra's algorithm
  • Bellman-Ford algorithm
  • Minimum spanning tree (Kruskal's and Prim's)
  • Practice: network delay time, cheapest flights within K stops

  • Merge sort and quicksort deep dive
  • Heap sort, counting sort, radix sort
  • Greedy strategy and when it applies
  • Interval problems (merge intervals, activity selection)
  • Practice: jump game, gas station, meeting rooms

  • Memoization (top-down) and tabulation (bottom-up)
  • Classic 1D DP: climbing stairs, house robber, coin change
  • Classic 2D DP: longest common subsequence, edit distance, unique paths
  • 0/1 Knapsack
  • Practice: longest increasing subsequence, word break, partition equal subset sum
Instructor

Vansh Thakur

Vansh Thakur is a software engineer and educator passionate about making technology approachable for everyone. With hands-on experience across Python, C++, web development, and AI applications, he brings real-world context to every lesson. His teaching style focuses on clear structure, practical projects, and building genuine confidence.

FAQs

Do I need prior knowledge of data structures before starting?
No, the course builds from scratch. Familiarity with at least one programming language (Python, Java, or C++) is recommended.

Which programming language is used in this course?
Problems and explanations use Python, but the patterns apply to any language. You are welcome to code in your preferred language.

How many problems will I solve over the course?
You will work through approximately 120–150 curated problems across all 12 weeks, progressing from easy to hard.

Is this course sufficient to crack FAANG interviews?
This course covers the core patterns that appear most frequently. Combined with consistent LeetCode practice, it provides a strong foundation for top-tier interviews.

How much time per week should I dedicate?
Plan for 10–15 hours per week including lessons, guided problem-solving, and independent practice.

What if I get stuck on a problem?
Each week includes worked solutions with detailed explanations. You can also bring questions to live sessions or the course community.

Will I receive a certificate?
Yes, a certificate of completion is issued upon finishing all 12 weekly modules.

Student Reviews

No reviews yet. Be the first to review!

No approved reviews yet.

Write a Review

Ready to start your journey?

Login to Enroll