This repository serves as a complete documentation of my Data Structures and Algorithms learning journey, spanning over 110 days of dedicated practice. It contains 500+ problem solutions and implementations covering the entire spectrum of DSA concepts - from basic array operations to advanced graph algorithms.
What started as a beginner's exploration of programming fundamentals has evolved into a comprehensive collection that includes implementations of core data structures (arrays, linked lists, stacks, queues, trees, heaps, graphs), classic algorithms (sorting, searching, recursion, dynamic programming), and solutions to real-world coding challenges from platforms like LeetCode and Coding Ninjas.
Each day's folder represents a milestone in this learning journey, with problems carefully selected to build upon previous concepts while introducing new challenges. The repository also includes dedicated revision sessions and topic-specific deep dives, making it both a learning resource and a reference guide for anyone preparing for technical interviews or strengthening their DSA fundamentals.
Whether you're a beginner starting your DSA journey or someone looking to revise concepts, this repository offers well-commented, clean C++ implementations with a logical progression from basics to advanced topics.
This repository contains solutions to various DSA problems implemented primarily in C++, covering fundamental to advanced concepts. The practice follows a structured approach with daily problem-solving sessions, topic-wise revisions, and platform-specific challenges.
Progressive learning path covering:
- Fundamentals (Days 1-10): Basics, loops, patterns, arrays, sorting algorithms
- Advanced Arrays (Days 11-15): 2D arrays, matrix operations, Pascal's triangle
- Pointers & Memory (Days 16-17): Pointer concepts, MCQs, memory management
- Recursion (Days 17-20): Recursive algorithms, merge sort, quick sort
- OOP Concepts (Days 21-23): Classes, inheritance, polymorphism, encapsulation
- Linked Lists (Days 23-25, 51-56, 61-62, 78-82): Singly, doubly, circular linked lists
- Stacks (Days 26, 35-36, 42-47, 58-59): Stack implementations and applications
- Queues (Days 28-29, 48-50, 60): Linear, circular, and deque implementations
- Trees (Days 63-73, 83): Binary trees, BST, tree traversals, views
- Heaps (Days 74-75, 84-87): Min/max heaps, heap sort, priority queues
- Hash Maps (Day 76): Hashing concepts and implementations
- Tries (Days 77, 88): Trie data structure and applications
- Graphs (Days 89-97, 103-105): Graph representations, BFS, DFS, traversals
- Revisions (Days 98-110): Topic-wise comprehensive revisions
basics/- Array fundamentalsbinary_search/- Binary search variationsproblems/- Array problem solutions
- Pointer basics and introduction
- Double pointers
- Pointers with functions
- Pointers in arrays
Intensive coding sessions covering:
- Array manipulations
- Binary search problems
- Two-pointer techniques
- Sorting algorithms
Platform-specific problem solutions including:
- Stack operations
- String manipulations
- Array searching and sorting
- Duplicate finding algorithms
- Arrays (1D, 2D, Multi-dimensional)
- Strings & Character Arrays
- Linked Lists (Singly, Doubly, Circular)
- Stacks & Queues
- Trees (Binary Trees, BST)
- Heaps (Min Heap, Max Heap)
- Hash Maps
- Tries
- Graphs
- Searching: Linear Search, Binary Search
- Sorting: Bubble Sort, Selection Sort, Insertion Sort, Merge Sort, Quick Sort, Heap Sort
- Recursion & Backtracking
- Tree Traversals: Inorder, Preorder, Postorder, Level Order
- Graph Traversals: BFS, DFS
- Two Pointer Technique
- Sliding Window
- Dynamic Programming (basics)
- Time & Space Complexity Analysis
- Object-Oriented Programming
- Pointers & Memory Management
- Recursion Patterns
- Problem-Solving Strategies
- Primary Language: C++
- Build System: CMake (build configurations in various directories)
- IDE: VS Code (configuration files in
.vscode/) - Version Control: Git
- Total Days: 110+
- Problems Solved: 500+
- Topics Mastered: 15+
- Platforms: LeetCode, Coding Ninjas, Custom Practice
Most programs can be compiled using:
g++ -std=c++17 filename.cpp -o filename
./filenameEach day's folder contains:
- Source files (
.cpp) - Compiled executables
- Problem-specific implementations
# Navigate to specific day
cd "DAY 1"
# Compile and run
g++ intro.cpp -o intro
./intro- Consistent Practice: 110+ consecutive days of problem-solving
- Comprehensive Coverage: From basics to advanced topics
- Multiple Revisions: Dedicated revision sessions for each topic
- Real-world Problems: LeetCode and platform challenges
- Clean Code: Well-structured and commented implementations
- Progressive Learning: Building complexity gradually
This repository reflects learning from various sources including:
- Online coding platforms (LeetCode, Coding Ninjas)
- DSA courses and tutorials
- Self-practice and problem-solving
- Stretch coding sessions
Currently focusing on:
- Advanced graph algorithms
- Dynamic programming patterns
- System design problems
- Competitive programming techniques
Feel free to explore the code, suggest improvements, or use it as a reference for your own DSA journey!
Note: This is an active learning repository. Code is continuously being added and refined as I progress through more advanced topics and revisit fundamentals.
Last Updated: November 2025