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.

Below you can find the list of topics still not available:

Topic	Description
Longest Increasing Subsequence DP (Soon available)	Finding increasing subsequences with DP and binary search optimization.
2D Grid DP (Soon available)	DP on grids, path counting, matrix transformations, interval DP, and multi-dimensional state spaces.
String DP (Soon available)	DP applied to strings: alignment, edit distance, palindromes, and pattern matching.
State Machine DP (Soon available)	DP using states and transitions, including stock trading problem variants.
Tree & Graph DP (Soon available)	Dynamic programming on trees and graphs: post-order DP, rerooting, and DAG-based DP.
Advanced DP Techniques (Soon available)	Bitmask DP, digit DP, and probability DP: advanced state modeling techniques.
String Matching (Soon available)	KMP, Rabin-Karp, and other substring search algorithms.
Binary Indexed Tree / Segment Tree (Soon available)	Range queries and updates efficiently.
Maths / Geometry (Soon available)	Number theory, combinatorics, and geometric algorithms.
Line Sweep (Soon available)	Processing events sorted by coordinate for interval problems.
Suffix Array (Soon available)	Advanced string processing and pattern matching.