Skip to content
SudoSecurity

Sections

Course

Algorithms & Data Structures in Practice

The data structures and algorithms that actually show up in real engineering — hash maps, trees, graphs, dynamic programming — with complexity reasoning you can apply to your own code, not just interview problems.

9 lessons

Course Q&A

Foundations

Big-O thinking, the core structures, and why the right structure is the whole optimization.

  1. 01Big-O as an Engineering ToolComplexity isn't trivia — it's how you predict whether code will survive real data. The analysis that catches a slow function before it ships.18mOpen
  2. 02Hash Maps and Sets: The Default StructureO(1) lookups change everything — two-sum, deduplication, grouping, and caching are all the same pattern: hash the key.18mOpen
  3. 03Trees, Heaps, and Queues: Ordered StructuresWhen order matters — heaps for priority queues, BSTs for range queries, queues for FIFO processing — the structures behind schedulers, indexes, and search.20mOpen

Graphs and Search

BFS, DFS, Dijkstra — the algorithms behind routing, dependencies, and reachability.

  1. 01BFS and DFS: Traversal as Problem-SolvingBreadth-first and depth-first are the same idea with different data structures — BFS for shortest path in unweighted graphs, DFS for existence and topology.22mOpen
  2. 02Topological Sort and Dependency OrderBuild systems, task schedulers, and course prerequisites all reduce to the same problem — order the nodes so every dependency comes first.20mOpen
  3. 03Shortest Path: BFS, Dijkstra, and When Each WorksUnweighted graphs use BFS; weighted graphs need Dijkstra — and Dijkstra is just BFS with a priority queue.20mOpen

Applied Techniques

Sorting, dynamic programming, and the patterns that show up in real systems.

  1. 01Sorting: More Than `sort()`When the built-in sort isn't enough — counting sort, radix sort, topological sort, and the trade-offs behind each.18mOpen
  2. 02Dynamic Programming: Memoization as OptimizationWhen recursion recomputes the same thing — overlapping subproblems, memoization, and the bottom-up tabulation that turns exponential into polynomial.22mOpen
  3. 03Greedy and Two-Pointer PatternsThe patterns that solve a surprising number of problems — greedy choice, two pointers on sorted data, sliding windows — and when each applies.18mOpen