Week 1: Arrays & Strings

• Day 1-2: Introduction to arrays, basic operations (insertion, deletion), array traversal.

o Practice: Easy-level problems (e.g., finding maximum/minimum in an array, reverse

• Day 3-4: Sorting techniques (Bubble Sort, Selection Sort, Insertion Sort).

o Practice: Implement these sorting algorithms and solve sorting problems.

• Day 5-6: Two-pointer technique, sliding window problems.

o Practice: Problems like "Pair with a given sum," "Longest substring without repeating
characters."

• Day 7: Strings – string manipulation, basic string operations.

o Practice: Reverse a string, check if a string is a palindrome.

Week 2: Linked Lists

• Day 1-2: Introduction to Linked Lists (Singly Linked List) – creation, insertion, deletion.

o Practice: Problems like reversing a linked list, detecting a cycle in a linked list.

• Day 3-4: Doubly Linked Lists and Circular Linked Lists.

o Practice: Implement doubly linked list operations.

• Day 5-6: Linked List problems – merging two sorted lists, intersection point of two linked
lists.

o Practice: Medium-level problems on linked lists.

• Day 7: Revision of Arrays and Linked Lists.

o Practice: Mixed problems combining arrays and linked lists.

Week 3: Stacks and Queues

• Day 1-2: Stacks – basic operations, implementation using arrays/linked lists.

o Practice: Valid parentheses, next greater element, implement a stack using queues.

• Day 3-4: Queues – basic operations, implementation using arrays/linked lists.

o Practice: Implement queue using stack, circular queue problems.

• Day 5-6: Applications of stacks and queues – expression evaluation (postfix, infix), balanced
parentheses.

o Practice: Solve problems like "Largest rectangle in a histogram" (stack-based).

o Practice: Basic problems on deque, implement a priority queue.

Week 4: Recursion and Backtracking

• Day 1-2: Basics of recursion – factorial, Fibonacci, power of a number.

o Practice: Recursion-based problems like "N-th Fibonacci number" using

• Day 3-4: Advanced recursion – solving problems with multiple recursion branches.

o Practice: Tower of Hanoi, permutations of a string.

• Day 5-6: Introduction to backtracking – N-Queens problem, Sudoku solver.

o Practice: Basic backtracking problems (subset sum, generate all subsets).

• Day 7: Revision of recursion and backtracking.

o Practice: Mixed problems that use recursion and backtracking.

Week 5: Trees

• Day 1-2: Introduction to trees – binary trees, tree traversals (in-order, pre-order, post-order).

o Practice: Basic tree traversal problems.

• Day 3-4: Binary Search Tree (BST) – insertion, deletion, search.

o Practice: Check if a tree is a BST, lowest common ancestor in a BST.

• Day 5-6: Advanced tree problems – height of a tree, diameter of a binary tree.

o Practice: Medium-level problems like "Serialize and deserialize a binary tree."

• Day 7: Revision of trees.

o Practice: Mixed tree problems (basic to advanced).

Week 6: Graphs

• Day 1-2: Introduction to graphs – representation (adjacency list, adjacency matrix), BFS, DFS.

o Practice: Implement BFS and DFS, basic graph traversal problems.

• Day 3-4: Graph algorithms – Dijkstra’s algorithm, shortest path.

o Practice: Shortest path problems in unweighted and weighted graphs.

• Day 5-6: Graph problems – detecting cycles in directed and undirected graphs, connected
components.

o Practice: Problems like "Number of islands" (graph representation of grids).

o Practice: Mixed graph traversal and algorithm problems.

Week 7: Dynamic Programming (DP)

• Day 1-2: Introduction to DP – memoization vs. tabulation, basic problems like Fibonacci, coin
change problem.

o Practice: Easy DP problems to get comfortable with the approach.

• Day 3-4: Advanced DP – longest increasing subsequence, knapsack problem.

o Practice: Medium-level DP problems.

• Day 5-6: DP with strings – longest common subsequence, edit distance.

o Practice: Solve string-based DP problems.

• Day 7: Revision of DP.

o Practice: Mixed DP problems from various difficulty levels.

Week 8: Revision & Mock Tests

• Day 1-2: Revision of Arrays, Strings, and Linked Lists.

o Practice: Solve 2-3 problems from each topic.

• Day 3-4: Revision of Stacks, Queues, and Recursion/Backtracking.

o Practice: Solve mixed problems involving these concepts.

• Day 5-6: Revision of Trees, Graphs, and DP.

o Practice: Mixed problems to revise all three topics.

• Day 7: Take a mock test – timed coding challenges to simulate real exam or interview
conditions.

Tips to Follow During These Two Months

• Practice daily: Aim to solve at least 3-5 problems each day from the topic you're studying.

• Focus on problem-solving: Understand the logic behind the solutions rather than
memorizing them.

• Track progress: Use platforms like LeetCode or HackerRank to track your performance and
adjust your weak areas.

• Review mistakes: After each problem, review the solution, especially if you got it wrong.
Understand your mistakes and learn from them.