Programming and interview foundations
Software Engineer
Learn the data structures, algorithms, and problem-solving patterns used in technical interviews and everyday engineering decisions.
By the end
Reason about performance, choose suitable data structures, and solve unfamiliar programming problems systematically.
Start here
Start with Big-O Big-O Notation
Count how much work code performs, then describe how that work grows with the input.
Learn how programs use data
Start with runtime, then learn the containers used in nearly every program.
- AlgorithmsBig-O NotationCount how much work code performs, then describe how that work grows with the input.
- AlgorithmsArraysLearn how indexed storage works, what each array operation costs, and how one safe pass grows into in-place and matrix algorithms.
- AlgorithmsStringsTreat text as an indexed sequence first, then add immutable output, word boundaries, symmetry, runs, direct search, and grammar one idea at a time.
- AlgorithmsHash Tables and SetsProgress from remembering whether a key exists to storing counts, complements, canonical signatures, and one-to-one mappings.
Build and search structures
Work with linked data, call stacks, ordering, and efficient search.
- AlgorithmsLinked ListsNo indexing, no contiguous memory — just nodes pointing to the next one, which is exactly what makes O(1) insertion possible.
- AlgorithmsStacks and QueuesA stack remembers what to undo; a queue remembers what to do next, in the order it arrived.
- AlgorithmsRecursionA function that trusts a smaller call to itself to solve a smaller version of the same problem — with a base case as the trapdoor that stops the falling.
- AlgorithmsSimple SortingLearn bubble, selection, and insertion sort by watching which part of the array becomes permanently ordered after each pass.
- AlgorithmsDivide-and-Conquer SortingSorting is rarely the answer by itself — it's the setup that turns a hard search into a single, boring pass.
- AlgorithmsBinary SearchBinary search isn't about sorted arrays — it's about any monotonic true/false predicate, and the array is just the most common place one shows up.
Recognize reusable patterns
Replace repeated brute force with small, recognizable techniques.
- AlgorithmsTwo PointersTwo indices moving through a structure with a clear rule, so every step throws away work you never need to redo.
- AlgorithmsSliding WindowA window that only ever grows on the right and shrinks on the left — each edge crosses every position at most once, so the whole scan is O(n).
- AlgorithmsPrefix SumsOnce you know the running total up to every point, the sum of ANY range is just one subtraction away — no matter how long the range is.
- AlgorithmsIntervalsSort by start time, then a single left-to-right sweep answers almost every question about overlaps.
- AlgorithmsMonotonic StacksKeep only unresolved candidates in useful order, so many nearest-greater or nearest-smaller queries finish in one pass.
- Algorithms · OptionalTriesLet each character choose the next branch, so string queries depend on the key rather than the number of stored keys.
Solve connected and constrained problems
Move from trees and graphs to the techniques used for harder optimization problems.
- AlgorithmsTrees and Binary Search TreesTrees represent hierarchical relationships. Binary search trees add an ordering rule that makes search, insertion, and deletion follow one root-to-leaf path.
- AlgorithmsHeapsA heap keeps only one promise — instant access to the current best — and gives up full ordering to make that promise cheap to maintain.
- AlgorithmsGraphsMost 'graph problems' aren't handed to you as a graph at all — a grid, a word list, or a set of game states IS a graph the moment you decide what a 'node' and an 'edge' mean.
- AlgorithmsUnion-Find (Disjoint Set Union)Maintain connected groups while new links arrive, without searching the whole graph after every update.
- AlgorithmsTopological SortTurn directed prerequisites into a valid order, or expose the cycle that makes every order impossible.
- AlgorithmsGreedy AlgorithmsA greedy algorithm never looks back — it commits to the locally best choice at every step, and the whole challenge is proving that never backtracking still finds the global optimum.
- AlgorithmsBacktrackingBacktracking is just depth-first search over a tree of choices you build as you go, undoing each choice once you've explored where it leads.
- AlgorithmsDynamic ProgrammingA repeatable way to build larger answers from smaller answers and reuse work already completed.
- Algorithms · OptionalBit ManipulationRead integers as binary patterns, change selected positions with masks, and reuse a small set of identities in interview problems.