Data Structures and Algorithms

Below you can find the roadmap of my Data Structures and Algorithms (DSA) course, inspired by the Algomaster.io DSA patterns list. The arguments are in a specific order to build upon previously covered concepts.

Topic	Description
Time and Space Complexity	Understanding how algorithm performance is measured using Big-O notation and analyzing time-space tradeoffs.
Arrays	Arrays are one of the most fundamental data structures in computer science. They provide a way to store elements in a contiguous block of memory, allowing efficient access and manipulation.
Strings	Strings are fundamental data types serving as the foundation for text processing, pattern recognition, and encoding/decoding operations.
Bit Manipulation	Bit manipulation (bit wise) is one of the most powerful tools in computer science, allowing direct control over how data is represented and processed at the hardware level.
Hashtable	A hash table is a data structure that stores key-value pairs and allows extremely fast lookups, insertions, and deletions, typically in O(1) average time.
Two Pointers	The Two Pointers technique uses two indices to solve array problems in linear time O(n) instead of inefficient O(n²) nested loops.
Prefix Sum	The Prefix Sum technique precomputes cumulative information so that range sum queries can be answered in O(1) time.
Sliding Window	The Sliding Window pattern transforms O(n²) problems into O(n) solutions by maintaining a window over data and adjusting it incrementally.
Kadane's Algorithm	Kadane's Algorithm is a classic algorithm designed to efficiently find the maximum sum subarray within a one-dimensional array of numbers in O(n) time.
Matrix (2D Array)	Matrix problems focus on navigating rows and columns, managing boundaries, applying consistent traversal rules, and performing transformations on 2D arrays.
Linked List	A linked list is a data structure consisting of nodes where each node contains a value and a reference to the next node, enabling flexible insertions and deletions.
Stack	A stack is a fundamental LIFO (Last In, First Out) data structure where the last element added is the first one to be removed.
Queue	A queue is a fundamental FIFO (First In, First Out) data structure where the first element added is the first one to be removed.
Bucket sort	Bucket Sort is a distribution-based sorting algorithm that works by dividing elements into several buckets and then sorting each bucket individually. It is particularly effective for sorting numbers that fall within a bounded range or when sorting elements based on their frequency.
Recursion	A deep dive into recursion as a problem-solving technique, with practical TypeScript examples.
Merge Sort	A deep dive into Merge Sort as a divide-and-conquer algorithm, from array sorting to linked lists and advanced counting problems.
Quick Sort	An in-depth look at Quick Sort as a divide-and-conquer algorithm, focusing on partitioning, expected complexity, and selection problems.
Binary Search	Binary search is an efficient algorithm for finding an item from a sorted list of items. It works by repeatedly dividing the search interval in half.
Backtracking	Deep dive into the backtracking technique, a fundamental approach for combinatorial problems, permutation generation, and constraint satisfaction tasks.
Tree	A comprehensive guide to tree, including traversal techniques covering BFS (level-order) and DFS (pre-order, in-order, post-order) with formal tree definitions, tree types, traversal templates, problem patterns, and complexity analysis.
Binary Search Tree and Ordered Set	Deep dive into Binary Search Trees, Ordered Sets, and their applications in advanced algorithmic problems.
Tries	A comprehensive guide to Trie data structures, exploring their implementation, applications, and use cases.
Heaps	A heap is a complete binary tree stored as an array that enforces a priority ordering, enabling O(log n) insert and extract operations and powering greedy scheduling and two-heaps patterns.
Intervals	Interval merging, scheduling, and overlap problems. Techniques for efficiently handling ranges, detecting conflicts, and optimizing interval-based tasks.
K-Way Merge	Learn how to efficiently merge multiple sorted data sources using heaps, a fundamental pattern behind many advanced problems.
Data Structure Design	Data structure design is the art of composing primitive structures into custom abstractions that satisfy complex operational requirements under strict time and space constraints.
Greedy Algorithms	Greedy algorithms build solutions incrementally by making locally optimal choices at each step, relying on the greedy-choice property and optimal substructure to guarantee global optimality.
Graph	A comprehensive guide to graph, including traversal using Depth-First Search and Breadth-First Search, extending tree traversal techniques to general graphs with cycles, disconnected components, and implicit structures.
Topological Sort	A comprehensive guide to topological sorting on directed acyclic graphs, covering DFS-based and BFS-based approaches, cycle detection, and multi-level dependency resolution.
Union Find	A comprehensive guide to the Union Find (Disjoint Set Union) data structure, covering the forest representation, path compression, union by rank, inverse Ackermann analysis, and application patterns for dynamic connectivity problems.
Minimum Spanning Tree	A comprehensive guide to Minimum Spanning Trees, covering the cut property, Kruskal's algorithm with Union-Find, Prim's algorithm with a min-heap, and the trade-offs between the two approaches.
Shortest Path	A comprehensive guide to shortest path algorithms, covering Dijkstra's algorithm with a min-heap, the Bellman-Ford algorithm for graphs with negative weights, and their variations on grids and constrained problems.
Eulerian Circuit	A comprehensive guide to Eulerian circuits and paths, covering the necessary and sufficient conditions for their existence, Hierholzer's algorithm, De Bruijn sequences, and applications to graph traversal problems.
DP Foundations & 1D DP	A comprehensive guide to dynamic programming: optimal substructure, overlapping subproblems, memoization vs tabulation, state definition, recurrence relations, and space optimization, taught through one-dimensional DP problems.
Knapsack DP	A comprehensive guide to knapsack dynamic programming: the 0/1 knapsack pattern for bounded items and the unbounded knapsack pattern for unlimited items, with the critical inner loop direction insight that distinguishes them.
Longest Increasing Subsequence DP	A comprehensive guide to the Longest Increasing Subsequence problem: the O(n²) DP formulation, the O(n log n) patience sorting optimization, counting and reconstruction variants, and the unifying view through Dilworth's theorem.
2D Grid DP	A comprehensive guide to dynamic programming on two-dimensional grids: path counting, minimum and maximum path sums, obstacle variants, matrix-local recurrences, transition optimization, multi-dimensional grid states, and rolling-array space reduction.
String DP	A complete guide to dynamic programming over strings: the two-index prefix table, two-sequence alignment with longest common subsequence, edit distance, distinct subsequences and interleaving, palindromic substructure over intervals, segmentation and decoding of a single string, wildcard pattern matching, and rolling-row space optimization.
State Machine DP	A guide to dynamic programming over finite automata: states as qualitative modes rather than positions, transitions weighted by gains and costs, the whole stock trading family from one transaction to k transactions with cooldowns and fees, the collapse into rolling scalars, and the layered DAG longest path view.
Tree & Graph DP	Dynamic programming on trees and graphs: post-order DP on rooted trees, states made of a node plus a mode, recurrences that build structures instead of values, rerooting with two traversals, and DP over the DAG induced by a shortest-path algorithm.
Advanced DP Techniques	Advanced state modelling in dynamic programming: bitmask DP encoding a set as an integer, digit DP walking the decimal representation of a bound, and probability DP where the value of a state is a probability or an expectation.
String Matching	A rigorous treatment of exact string matching, covering the naive scan, borders and the Knuth-Morris-Pratt prefix function, the pattern-separator-text concatenation, the Rabin-Karp polynomial rolling hash, and binary search on the answer length.
Binary Indexed Tree / Segment Tree	A comprehensive guide to the two classical structures for dynamic range queries: the segment tree, in its recursive and iterative bottom-up form, and the Fenwick tree, with its lowest-set-bit decomposition, coordinate compression and inversion counting.
Maths / Geometry	A guide to the mathematical toolbox behind algorithmic problem solving: digit manipulation without strings, fixed width integer overflow, divisibility and the Euclidean algorithm, Legendre's formula, modular arithmetic, and exact computational geometry on integer coordinates.
Line Sweep	The sweep line technique: turning geometric and interval problems into a sorted sequence of events, with the status structures, tie-breaking rules and lazy deletion idioms that make the single pass correct.

Every topic of the roadmap is now available. The course covers the whole Algomaster.io DSA patterns list, from the foundations of complexity analysis to the sweep line techniques used on geometric problems. Each topic ends with a set of exercises, collected also in the exercises page, and solved in TypeScript in my Algomaster Solutions repository.