DSA with Python Learning Plan:
23/10/2024: Starting Date
-----------------------------------------------------------------------------------
------
Week 1: Python Fundamentals Refresher (If needed)
Before jumping into DSA, make sure you're comfortable with Python, especially the
parts you'll need for DSA.
Day 1:
Topics: Python basics, data types (int, float, string), conditionals, loops.
Practice: Write Python programs that use loops and conditionals.
Goal: Be able to write simple programs like number comparisons, sum of a list,
etc.
Day 2:
Topics: Functions, recursion, and the `math` library.
Practice: Solve problems involving recursion like factorial and Fibonacci
numbers.
Goal: Be comfortable with Python functions and recursion.
Day 3:
Topics: Lists, list comprehensions, tuples, sets, and dictionaries.
Practice: Practice list slicing, dictionary operations, and set operations.
Goal: Be fluent in manipulating these data structures.
-----------------------------------------------------------------------------------
--Done </> 1/11/2024
-----------------------------------------------------------------------------------
--
Week 2: Introduction to Data Structures
Day 4: Lists and Arrays
Theory: Understand arrays and dynamic arrays (Python lists).
Practice: Array rotations, finding min/max in a list, reversing an array.
Goal: Solid understanding of arrays and how Python lists work.
Day 5: Stacks
Theory: What is a stack? LIFO principle, common operations (push, pop, peek).
Practice: Implement stack using lists, solve problems like balanced parentheses
and reverse a string using a stack.
Goal: Be able to implement and use a stack in Python.
Day 6: Queues
Theory: FIFO principle, types of queues (simple, circular, deque).
Practice: Implement a queue using lists and `deque`, solve problems like the
first non-repeating character in a string.
Goal: Know how to use Python's `deque` for queue operations.
Day 7: Recap of Week 2 + Coding Practice
Review the concepts of stacks and queues.
Solve at least 5-6 problems combining stacks, queues, and lists.
-----------------------------------------------------------------------------------
--
Done </> 07/11/2024
------------------------------------------------------------------------------
Week 3: Linked Lists
Day 8: Singly Linked List
Theory: Nodes, creating a linked list, traversing a linked list.
Practice: Implement a singly linked list, solve problems like reversing a linked
list.
Goal: Be able to implement and manipulate a linked list.
- **Day 9: Doubly Linked List**
- **Theory**: Doubly linked lists vs singly linked lists, operations on doubly
linked lists.
- **Practice**: Implement a doubly linked list, solve problems like deleting
nodes from the list.
- **Goal**: Understand when to use doubly linked lists and how to implement them.
- **Day 10: Circular Linked List**
- **Theory**: Circular linked list and its uses.
- **Practice**: Implement a circular linked list, solve problems like detecting a
loop in a linked list.
- **Goal**: Be comfortable with different types of linked lists.
- **Day 11: Recap + Practice**
- Solve linked list problems from platforms like LeetCode or HackerRank.
- **Goal**: Solidify your understanding of linked lists through problem-solving.
#### **Week 4: Trees and Heaps**
- **Day 12: Introduction to Trees**
- **Theory**: Tree terminology (root, leaf, height, etc.), binary trees.
- **Practice**: Implement a binary tree, traverse a tree (in-order, pre-order,
post-order).
- **Goal**: Understand tree structures and traversals.
- **Day 13: Binary Search Trees (BST)**
- **Theory**: What is a BST? Operations like insertion, search, and deletion.
- **Practice**: Implement a BST, solve problems like checking if a tree is a BST.
- **Goal**: Understand how to work with binary search trees.
- **Day 14: Heaps**
- **Theory**: Min-heap and max-heap, heap operations.
- **Practice**: Implement a heap using Python's `heapq`, solve problems like
finding the k-largest elements.
- **Goal**: Be able to solve heap-related problems in Python.
- **Day 15: Recap + Practice**
- Review tree and heap concepts, solve at least 5-6 problems on trees and heaps.
- **Goal**: Become proficient in tree traversal and heap operations.
#### **Week 5: Graphs**
- **Day 16: Introduction to Graphs**
- **Theory**: Graph terminology (vertices, edges, etc.), representation
(adjacency list/matrix).
- **Practice**: Implement graph traversal (BFS, DFS).
- **Goal**: Understand how to represent and traverse a graph.
- **Day 17: Shortest Path Algorithms**
- **Theory**: Dijkstra’s algorithm, Bellman-Ford algorithm.
- **Practice**: Solve shortest path problems using Dijkstra’s algorithm.
- **Goal**: Be able to implement and use shortest path algorithms.
- **Day 18: Graph Algorithms (Advanced)**
- **Theory**: Topological sorting, connected components.
- **Practice**: Implement topological sort and detect cycles in a graph.
- **Goal**: Understand advanced graph algorithms.
- **Day 19: Recap + Graph Problem Solving**
- Solve 5-6 graph-related problems from coding platforms.
- **Goal**: Strengthen your problem-solving skills with graph algorithms.
#### **Week 6: Searching and Sorting Algorithms**
- **Day 20: Searching Algorithms**
- **Theory**: Linear search, binary search, and their complexities.
- **Practice**: Implement linear search and binary search, solve problems like
finding the first occurrence of an element.
- **Goal**: Master searching techniques.
- **Day 21: Sorting Algorithms (Part 1)**
- **Theory**: Bubble sort, selection sort, insertion sort.
- **Practice**: Implement these sorting algorithms, understand their time
complexities.
- **Goal**: Be proficient in basic sorting algorithms.
- **Day 22: Sorting Algorithms (Part 2)**
- **Theory**: Quick sort, merge sort, and heap sort.
- **Practice**: Implement quick sort and merge sort, solve problems that require
efficient sorting.
- **Goal**: Master efficient sorting techniques.
- **Day 23: Practice Sorting and Searching Problems**
- Solve a combination of problems involving searching and sorting.
- **Goal**: Solidify your knowledge through problem-solving.
#### **Week 7: Dynamic Programming (DP)**
- **Day 24: Introduction to DP**
- **Theory**: Recursion vs dynamic programming, memoization, and tabulation.
- **Practice**: Solve basic DP problems like Fibonacci, climbing stairs.
- **Goal**: Understand the basic concepts of dynamic programming.
- **Day 25: DP with 1D Problems**
- **Practice**: Solve problems like coin change, maximum subarray sum.
- **Goal**: Get comfortable with 1D dynamic programming problems.
- **Day 26: DP with 2D Problems**
- **Practice**: Solve problems like longest common subsequence, edit distance.
- **Goal**: Master more complex DP problems.
- **Day 27: Recap + DP Problem Solving**
- Solve 5-6 dynamic programming problems.
- **Goal**: Strengthen your understanding of dynamic programming.
#### **Week 8: Recap + Mock Interviews**
- **Day 28-30: Interview Preparation**
- Review all concepts and solve problems across all topics.
- Focus on coding interview questions, timing yourself to simulate real interview
conditions.
- **Mock Interviews**: Test your knowledge by solving problems in a timed
environment and reviewing your solutions.
- **Goal**: Be prepared for both theoretical and coding questions.
---
### **General Tips for the Journey:**
- **Practice Daily**: The key to mastering DSA is consistent practice. Work on
coding platforms like LeetCode, Codeforces, or HackerRank.
- **Time Management**: As interviews are time-sensitive, practice solving problems
within a set time frame.
- **Mock Interviews**: Try mock interviews to simulate real interview scenarios.
- **Revise**: Revisit and revise complex topics like trees, graphs, and dynamic
programming regularly.
Let me know if you need more details or additional practice resources!