A comprehensive, well-structured, and actively maintained DSA reference repository — built from the ground up with clean code, educational comments, and multiple solution approaches.
⭐ If this repository helped you learn, please consider giving it a star — it keeps this project alive and helps others discover it!
This is a complete, structured, and ever-growing Data Structures and Algorithms reference repository written entirely in modern C++ (C++17). Every topic is organized from first principles — starting with the theoretical foundation, followed by clean implementations, and ending with curated problem sets ranging from easy to hard.
The goal is simple: build the strongest possible DSA foundation, whether you're preparing for technical interviews, competitive programming, university coursework, or simply want to understand how computers think at a fundamental level.
This repository covers over 260 files across 24+ topic folders — and is actively being expanded.
| Audience | How This Helps |
|---|---|
| 🎓 CS / EEE Students | Clear theory + implementation to complement university coursework |
| 💼 Interview Candidates | Brute → Better → Optimal solution progressions mirror real interview thinking |
| 🏆 Competitive Programmers | STL mastery, algorithmic patterns, and categorized problem sets |
| 🌱 Beginners | Step-by-step comments explaining not just what the code does, but why |
| 🔬 Experienced Developers | Clean, production-style code with time/space complexity analysis |
Most DSA repositories are just dumps of code. This one is different — it's designed to teach and demonstrate engineering quality at the same time.
- ✅ Brute → Better → Optimal — Every non-trivial problem provides multiple solution approaches, progressing in efficiency
- ✅ Complexity Analysis — Time and space complexity explained at the end of every function, not just stated
- ✅ Doxygen-style Documentation — All functions documented with parameter descriptions and return values
- ✅ Educational Comments — Line-by-line logic explanation inside functions, written for learning, not just reference
- ✅ Industry-Standard Style — camelCase naming, logical section separators, clean headers — production-grade code habits
- ✅ Problem Statements Included — Each file includes the problem it solves at the top, so the file is self-contained
- ✅ STL Mastery Section — A dedicated deep-dive into the C++ Standard Template Library before any data structures
- ✅ OS-Level Application — CPU scheduling algorithms implemented in C++ to connect DSA concepts to systems programming
complete-data-structure-and-algorithms-using-cpp/
│
├── 00_STLC++/ ← C++ STL: Vectors, Iterators, Algorithms, Pairs,
│ ├── 01_Vector and Iterators/ Sets, Maps, Other Containers, and Applied STL
│ ├── 02_STL Algorithms/
│ ├── 03_Pair and Tuple/
│ ├── 04_Sets/
│ ├── 05_Maps/
│ ├── 06_Other Containers/
│ └── 07_Applying STLs/
│
├── 01_Pointers/ ← Pointer basics, arithmetic, arrays, double pointers
├── 02_Dynamic Memory Allocation/ ← Heap memory, references, static/global/const variables
├── 03_Mathematics/ ← GCD, primes, Sieve, power function, nCr, Fibonacci
├── 04_Patterns/ ← 19 classical pattern problems (loops & logic)
│
├── 05_Recursion/ ← Basic → Medium recursive problems
│ ├── 01 Basic/ (Factorial, binary search, palindrome, subsequences...)
│ ├── 02 Easy/
│ └── Medium/ (Tower of Hanoi, phone keypad, subsequences)
│
├── 06_Strings/ ← Easy → Hard string problems
│ ├── 01 Basic Problems/ (Reverse, palindrome)
│ ├── 02 Easy/ (Roman numeral, pangram, anagram rotation)
│ ├── 03 Medium/ (Sliding window, large factorial, sorting vowels)
│ └── 04 Hard/ (KMP — LPS array, min chars to palindrome)
│
├── 07_Sorting Algorithms/ ← Selection, Bubble, Insertion, Quick, Merge,
│ Count Sort, DNF, Wave Sort (recursive variants too)
│
├── 08_Arrays/ ← 38 problems: Easy → Hard
│ ├── 01_Easy/ (Rotation, sliding window, two pointers, prefix sum)
│ ├── 02_Medium/ (Kadane's, next permutation, spiral matrix, set zeros)
│ └── 03_Hard/ (Pascal's triangle, 3Sum, 4Sum, XOR subarrays, merge intervals)
│
├── 09_OOP/ ← 41 files covering all OOP pillars in C++
│ (Classes, constructors, operator overloading,
│ inheritance, polymorphism, virtual functions,
│ friend class/function, abstract classes)
│
├── 10_Binary Search/ ← Binary search fundamentals
│
├── 11_Linked List/ ← 33+ Singly LL + 6 Doubly LL + 6 Advanced problems
│ ├── 01_Singly Linked List/ (Detect/remove cycles, merge K sorted, clone with random ptr)
│ ├── 02_Doubly Linked List/
│ └── 03_Others/ (Circular LL, browser history design, flatten LL)
│
├── 12_Stacks/ ← Stack implementations + Infix/Prefix/Postfix
│ ├── 01 Learning/ conversions + Monotonic Stack problems
│ ├── 02 Prefix Infix Postfix/ (Trapping rain water, next greater element)
│ └── 03 Monotonic Stack Problems/
│
├── 13_Queues/ ← Queue theory, circular array, LL-based, STL, stack-queue
│
├── 14_Trees/ ← General N-ary tree: traversals, height, depth, leaf count
│
├── 15_Binary Tree/ ← 43 problems on binary trees
│ (All traversals iterative + recursive, diameter, LCA,
│ burn tree, Morris traversal, serialize/deserialize)
│
├── 16_Binary Search Trees/ ← 18 BST problems
│ (Insert/delete, ceil/floor, LCA, recover BST, BST iterator)
│
├── 18_Graph Data Structure/ ← Graph intro, BFS, DFS (connected + disconnected graphs)
│
├── 19_Hashmap/ ← Hashmap internals: bucket array, hash codes,
│ collision handling, custom hashmap class
│
├── 20_Priority Queue And Heaps/ ← Heap theory, min-PQ, heapify, heap sort,
│ Kth smallest/largest element
│
├── 21_Bit Manipulation/ ← 19 problems: set/clear/toggle bits, XOR tricks,
│ power set, single number variants
│
├── 22_Sliding Window & 2 Pointers/ ← Max points from cards, longest unique substring
│
├── 23_Operating System Problems/ ← FCFS, SJF, Priority (preemptive + non-preemptive),
│ Round Robin scheduling algorithms in C++
│
└── 24_Greedy Algorithm Problems/ ← Easy: coins, cookies, lemonade change
├── 01 Easy/ Medium: jump game, job scheduling, meeting rooms
└── 02 Medium/
This repository is actively maintained and being expanded. Here's what's planned:
| Topic | Status |
|---|---|
| ✅ STL, Pointers, OOP, Mathematics | Complete |
| ✅ Recursion, Strings, Sorting | Complete |
| ✅ Arrays (Easy → Hard) | Complete |
| ✅ Linked List (Singly, Doubly, Circular) | Complete |
| ✅ Stacks, Queues, Trees, Binary Trees, BST | Complete |
| ✅ Graphs (BFS/DFS basics) | Partial |
| ✅ Hashmap, Heaps, Bit Manipulation | Complete |
| ✅ Sliding Window, Greedy, OS Scheduling | Partial |
| 🔄 Graph Algorithms (Dijkstra, Bellman-Ford, Floyd-Warshall, Prim's, Kruskal's, Topological Sort) | In Progress |
| 🔄 Dynamic Programming (0/1 Knapsack, LCS, LIS, Matrix Chain, DP on Trees) | Coming Soon |
| 🔄 Backtracking (N-Queens, Sudoku, Rat in Maze, Word Search) | Coming Soon |
| 🔄 Trie (Insert, Search, Word prefix, Auto-complete) | Coming Soon |
| 🔄 Segment Trees & Fenwick Trees | Coming Soon |
| 🔄 Disjoint Set Union (DSU) | Coming Soon |
| 🔄 Advanced Graph (SCC, Bridges, Articulation Points) | Planned |
📌 Watch / Star this repo to get notified as new content is added!
Every file in this repository follows a consistent, professional coding standard:
/*
* ============================================================
* File : exampleProblem.cpp
* Topic : Arrays
* Problem : Find the maximum subarray sum (Kadane's Algorithm)
* ============================================================
*/
#include <iostream>
#include <vector>
#include <climits>
using namespace std;
/**
* @brief Brute force approach — check all subarrays
* @param arr Input integer array
* @return Maximum subarray sum
*
* Time Complexity : O(n^2) — two nested loops over the array
* Space Complexity: O(1) — no extra space used
*/
int maxSubarraySumBrute(const vector<int>& arr) {
int maxSum = INT_MIN;
// Iterate over all possible starting points
for (int i = 0; i < arr.size(); i++) {
int currentSum = 0;
// Expand subarray from index i
for (int j = i; j < arr.size(); j++) {
currentSum += arr[j];
maxSum = max(maxSum, currentSum);
}
}
return maxSum;
}
/**
* @brief Optimal approach — Kadane's Algorithm
* @param arr Input integer array
* @return Maximum subarray sum
*
* Time Complexity : O(n) — single pass through the array
* Space Complexity: O(1) — constant space
*/
int maxSubarraySumOptimal(const vector<int>& arr) {
int maxSum = INT_MIN;
int currentSum = 0;
for (int num : arr) {
currentSum += num;
maxSum = max(maxSum, currentSum);
// Reset if current sum drops below zero — fresh start is better
if (currentSum < 0) currentSum = 0;
}
return maxSum;
}git clone https://github.com/ualiurrahat/complete-data-structure-and-algorithms-using-cpp.git
cd complete-data-structure-and-algorithms-using-cpp# Using g++ (recommended: C++17)
g++ -std=c++17 -o output filename.cpp
./outputBeginner Path:
03_Mathematics → 04_Patterns → 05_Recursion → 06_Strings → 08_Arrays
Intermediate Path:
07_Sorting → 11_Linked List → 12_Stacks → 13_Queues → 14_Trees → 15_Binary Tree
Advanced Path:
16_BST → 18_Graphs → 20_Heaps → 21_Bit Manipulation → 22_Sliding Window → 24_Greedy
Foundation (Parallel):
00_STL → 01_Pointers → 02_Dynamic Memory → 09_OOP
- IDE: VS Code with C/C++ Extension Pack
- Compiler: GCC / MinGW (Windows) or g++ (Linux/macOS)
- Standard: C++17 or later (
-std=c++17)
| # | Topic | Files | Difficulty Range |
|---|---|---|---|
| 00 | C++ STL (Vectors, Maps, Sets, Algorithms...) | 35+ | Beginner → Intermediate |
| 01 | Pointers | 7 | Beginner |
| 02 | Dynamic Memory Allocation | 9 | Beginner → Intermediate |
| 03 | Mathematics | 16 | Easy → Medium |
| 04 | Pattern Problems | 19 | Easy |
| 05 | Recursion | 25+ | Easy → Medium |
| 06 | Strings | 19 | Easy → Hard |
| 07 | Sorting Algorithms | 10 | Easy → Medium |
| 08 | Arrays | 38 | Easy → Hard |
| 09 | Object-Oriented Programming | 41 | Intermediate → Advanced |
| 10 | Binary Search | 1 | Easy |
| 11 | Linked Lists (Singly, Doubly, Circular) | 45+ | Easy → Hard |
| 12 | Stacks (+ Expression Conversions + Monotonic) | 15 | Easy → Hard |
| 13 | Queues | 6 | Easy → Medium |
| 14 | Trees (N-ary) | 17 | Easy → Medium |
| 15 | Binary Trees | 43 | Easy → Hard |
| 16 | Binary Search Trees | 18 | Medium → Hard |
| 18 | Graph Data Structure | 7 | Medium |
| 19 | Hashmap (Theory + Custom Implementation) | 9 | Medium → Advanced |
| 20 | Priority Queue & Heaps | 9 | Medium → Hard |
| 21 | Bit Manipulation | 19 | Easy → Hard |
| 22 | Sliding Window & Two Pointers | 2 | Medium |
| 23 | OS CPU Scheduling Algorithms | 6 | Applied |
| 24 | Greedy Algorithms | 9 | Easy → Medium |
Total: 260+ files · 24 topic modules · Actively growing
Md. Ualiur Rahman Rahat
Completed B.Sc. Engineering in Electrical & Electronic Engineering from Gopalganj Science and Technology University.
Pursuing Bachelors of Science in Computer Science from University of the People.
I'm an EEE graduate with a deep passion for software engineering and systems-level programming. I built this repository to document my journey through Data Structures & Algorithms with the rigor I wish I had found in a single place — clean code, real explanations, and honest progression from brute force to optimal.
Beyond DSA, I've worked in embedded systems and published research at the IEEE ICRPSET 2024 international conference:
📄 "Advanced Hybrid Algorithms for High-Efficiency Image Compression in Satellite and Drone Systems"
I believe the best way to truly master something is to teach it — and this repository is my effort to teach DSA, one well-commented file at a time.
This repository is licensed under the MIT License — free to use, share, and build upon with attribution.
⭐ Found this helpful? Star the repo — it takes 2 seconds and means a lot.
Made with consistency, curiosity, and a lot of g++ commands.