10-Day DSA Learning Plan (2 Hours/Day)
Day 1: Arrays & Basic Problem Solving
Time Allocation: 2 hours
Theory (30 mins): Array fundamentals, indexing, time/space complexity basics
Practice (90 mins): Core array problems
Key Concepts:
Array traversal and manipulation
Two-pointer technique
Sliding window basics
Prefix sum concept
Essential Problems:
1. Two Sum (LeetCode 1) - Hash map approach
2. Best Time to Buy and Sell Stock (LeetCode 121) - One pass solution
3. Contains Duplicate (LeetCode 217) - Set usage
4. Maximum Subarray (LeetCode 53) - Kadane's algorithm
5. Product of Array Except Self (LeetCode 238) - Left/right products
Study Resources:
Arrays section on GeeksforGeeks
LeetCode Arrays explore card
Day 2: Strings & Pattern Matching
Time Allocation: 2 hours
Theory (30 mins): String operations, ASCII values, common patterns
Practice (90 mins): String manipulation problems
Key Concepts:
String traversal and comparison
Palindrome checking techniques
Character frequency counting
Anagram detection
Essential Problems:
1. Valid Palindrome (LeetCode 125) - Two pointers
2. Valid Anagram (LeetCode 242) - Frequency counting
3. Longest Substring Without Repeating Characters (LeetCode 3) - Sliding window
4. Group Anagrams (LeetCode 49) - HashMap with sorted keys
5. Longest Palindromic Substring (LeetCode 5) - Expand around centers
Study Resources:
String algorithms on GeeksforGeeks
LeetCode String explore card
Day 3: Linked Lists
Time Allocation: 2 hours
Theory (45 mins): Linked list structure, types, operations
Practice (75 mins): Core linked list problems
Key Concepts:
Singly vs doubly linked lists
Fast and slow pointer technique (Floyd's algorithm)
Reversal techniques
Dummy node usage
Essential Problems:
1. Reverse Linked List (LeetCode 206) - Iterative and recursive
2. Merge Two Sorted Lists (LeetCode 21) - Pointer manipulation
3. Linked List Cycle (LeetCode 141) - Floyd's cycle detection
4. Remove Nth Node From End (LeetCode 19) - Two pointers
5. Add Two Numbers (LeetCode 2) - Digit-by-digit addition
Study Resources:
Linked Lists on GeeksforGeeks
LeetCode Linked List explore card
Day 4: Stacks & Queues
Time Allocation: 2 hours
Theory (30 mins): Stack/Queue operations, LIFO/FIFO principles
Practice (90 mins): Stack and queue problems
Key Concepts:
Stack operations: push, pop, peek
Queue operations: enqueue, dequeue
Monotonic stack/queue
Using stacks for parsing
Essential Problems:
1. Valid Parentheses (LeetCode 20) - Stack for matching
2. Min Stack (LeetCode 155) - Auxiliary stack technique
3. Evaluate Reverse Polish Notation (LeetCode 150) - Stack evaluation
4. Daily Temperatures (LeetCode 739) - Monotonic stack
5. Implement Queue using Stacks (LeetCode 232) - Two-stack approach
Study Resources:
Stack and Queue on GeeksforGeeks
LeetCode Stack/Queue explore cards
Day 5: Binary Trees (Basics)
Time Allocation: 2 hours
Theory (45 mins): Tree structure, terminology, traversal methods
Practice (75 mins): Basic tree problems
Key Concepts:
Tree traversals: inorder, preorder, postorder, level-order
Tree properties: height, depth, balanced trees
Binary tree vs binary search tree
Recursive thinking for trees
Essential Problems:
1. Maximum Depth of Binary Tree (LeetCode 104) - Recursive approach
2. Same Tree (LeetCode 100) - Recursive comparison
3. Invert Binary Tree (LeetCode 226) - Recursive swapping
4. Binary Tree Level Order Traversal (LeetCode 102) - BFS with queue
5. Symmetric Tree (LeetCode 101) - Recursive/iterative check
Study Resources:
Binary Trees on GeeksforGeeks
LeetCode Binary Tree explore card
Day 6: Binary Search Trees & Binary Search
Time Allocation: 2 hours
Theory (30 mins): BST properties, binary search algorithm
Practice (90 mins): BST and binary search problems
Key Concepts:
BST property: left < root < right
Binary search template and variations
Search space reduction
BST validation
Essential Problems:
1. Binary Search (LeetCode 704) - Classic implementation
2. Search in Rotated Sorted Array (LeetCode 33) - Modified binary search
3. Validate Binary Search Tree (LeetCode 98) - Inorder or bounds checking
4. Lowest Common Ancestor of BST (LeetCode 235) - BST property usage
5. Find Minimum in Rotated Sorted Array (LeetCode 153) - Binary search variant
Study Resources:
Binary Search Tree on GeeksforGeeks
LeetCode Binary Search explore card
Day 7: Recursion & Backtracking
Time Allocation: 2 hours
Theory (30 mins): Recursion principles, base cases, backtracking concept
Practice (90 mins): Recursion and backtracking problems
Key Concepts:
Recursion tree and stack frames
Base case and recursive case
Backtracking template
State space exploration
Essential Problems:
1. Subsets (LeetCode 78) - Generate all subsets
2. Permutations (LeetCode 46) - Generate all permutations
3. Combination Sum (LeetCode 39) - Backtracking with target
4. Generate Parentheses (LeetCode 22) - Valid combinations
5. Letter Combinations of Phone Number (LeetCode 17) - Mapping and recursion
Study Resources:
Recursion and Backtracking on GeeksforGeeks
LeetCode Recursion explore card
Day 8: Dynamic Programming (Basics)
Time Allocation: 2 hours
Theory (45 mins): DP principles, memoization vs tabulation
Practice (75 mins): Fundamental DP problems
Key Concepts:
Overlapping subproblems
Optimal substructure
Top-down (memoization) vs bottom-up (tabulation)
1D and 2D DP arrays
Essential Problems:
1. Climbing Stairs (LeetCode 70) - Basic DP pattern
2. House Robber (LeetCode 198) - 1D DP
3. Coin Change (LeetCode 322) - Classic DP problem
4. Longest Increasing Subsequence (LeetCode 300) - DP with binary search
5. Unique Paths (LeetCode 62) - 2D DP grid problem
Study Resources:
Dynamic Programming on GeeksforGeeks
LeetCode Dynamic Programming explore card
Day 9: Graphs (BFS/DFS)
Time Allocation: 2 hours
Theory (45 mins): Graph representation, BFS/DFS algorithms
Practice (75 mins): Graph traversal problems
Key Concepts:
Graph representations: adjacency list, adjacency matrix
BFS using queue
DFS using stack/recursion
Visited array usage
Connected components
Essential Problems:
1. Number of Islands (LeetCode 200) - DFS/BFS on grid
2. Clone Graph (LeetCode 133) - Graph traversal and cloning
3. Course Schedule (LeetCode 207) - Cycle detection in directed graph
4. Pacific Atlantic Water Flow (LeetCode 417) - Multi-source BFS/DFS
5. Graph Valid Tree (LeetCode 261) - Tree validation in graph
Study Resources:
Graph Data Structure on GeeksforGeeks
LeetCode Graph explore card
Day 10: Review & Mixed Practice
Time Allocation: 2 hours
Review (45 mins): Go through weak areas from previous days
Mixed Practice (75 mins): Challenging problems combining multiple concepts
Key Focus Areas:
Time and space complexity analysis
Pattern recognition
Edge case handling
Code optimization
Challenging Mixed Problems:
1. Merge k Sorted Lists (LeetCode 23) - Heaps/divide and conquer
2. Serialize and Deserialize Binary Tree (LeetCode 297) - Tree traversal
3. Word Ladder (LeetCode 127) - BFS shortest path
4. Trapping Rain Water (LeetCode 42) - Two pointers/stack
5. Longest Consecutive Sequence (LeetCode 128) - Hash set optimization
Final Review Checklist:
Can implement basic data structures from scratch
Understand time/space complexity of common algorithms
Recognize common patterns (two pointers, sliding window, etc.)
Can trace through recursive calls
Understand when to use each data structure
Daily Study Tips:
Before Starting Each Day:
1. Review previous day's concepts for 10 minutes
2. Set up your coding environment
3. Have a notebook ready for pattern notes
During Practice:
1. Read problem statement carefully
2. Think about approach before coding
3. Start with brute force, then optimize
4. Test with edge cases
5. Analyze time and space complexity
After Each Problem:
1. Note the pattern/technique used
2. Think about variations of the problem
3. Review optimal solutions if stuck
Weekly Milestones:
After Day 3: Comfortable with basic data structures
After Day 6: Can solve tree and search problems
After Day 9: Understanding of advanced algorithms
After Day 10: Ready for coding interview fundamentals
Additional Resources:
Visualization: VisuAlgo.net for algorithm animations
Practice: LeetCode, HackerRank, CodeSignal
Theory: "Cracking the Coding Interview" by Gayle McDowell
Video: Abdul Bari's Algorithm playlist on YouTube
Success Metrics:
Solve 80% of essential problems independently
Explain approach and complexity for each solution
Recognize patterns in new problems
Complete problems within reasonable time limits
Remember: Consistency is key. Focus on understanding patterns rather than memorizing solutions!
