> CHICIO CODING_Pixels. Code. Unplugged.
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. |
Below you can find the list of topics still not available:
| Topic | Description |
|---|---|
| Eulerian Circuit (Soon available) | Traversal visiting every edge exactly once. |
| 1-D DP (Soon available) | Dynamic programming on linear structures. |
| Knapsack DP (Soon available) | Solving 0/1 knapsack and subset sum problems. |
| Unbounded Knapsack DP (Soon available) | Knapsack problems with unlimited item repetitions. |
| Longest Increasing Subsequence DP (Soon available) | Finding increasing subsequences in arrays. |
| 2D (Grid) DP (Soon available) | DP on grids, path counting, and matrix transformations. |
| String DP (Soon available) | DP applied to strings for subsequence and substring problems. |
| Tree / Graph DP (Soon available) | Dynamic programming on hierarchical and graph structures. |
| Bitmask DP (Soon available) | Using bitmasks to represent subsets in DP. |
| Digit DP (Soon available) | Solving problems based on digit positions in numbers. |
| Probability DP (Soon available) | DP for expected value and probability problems. |
| State Machine DP (Soon available) | DP using states and transitions. |
| 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. |