All topics
Data structures and algorithms, visually
Every topic as a short animation you step through, with the running line of code highlighted in C++, Python or C#. Pick a topic to read the idea and the code, then watch it run.
Arrays
Scans, two pointers, windows and prefix sums over contiguous data.
Linear searchCheck every element in order until the target turns up. The only search that works on unsorted data.O(n)Binary searchOn a sorted array, look at the middle and throw away the half that cannot contain the target.O(log n)Two pointers: pair sumFind two values in a sorted array that add up to a target by closing in from both ends.O(n)Sliding window: max sum of kFind the largest sum of any k consecutive elements without re-adding the whole window each time.O(n)Kadane's algorithmLargest sum of any contiguous subarray, including arrays with negative numbers.O(n)Prefix sums: range queryPrecompute running totals once, then answer any "sum from l to r" question with a single subtraction.O(n) build, O(1) queryDutch national flag: sort 0, 1, 2Sort an array that only holds three distinct values in one pass with three pointers.O(n)Boyer-Moore majority voteFind the value that appears more than half the time, using one counter and no extra memory.O(n)
Strings
Character-level versions of the pointer and counting patterns.
Palindrome checkA string is a palindrome if it reads the same in both directions. Compare from the outside in.O(n)Longest substring without repeatsA variable-size sliding window: grow on the right, and jump the left edge past any repeated character.O(n)Valid anagramTwo words are anagrams if they use exactly the same letters. Count up for one word and down for the other.O(n)
Hashing
Trade memory for O(1) lookups with Dictionary and HashSet.
Sorting
The classic sorts, from quadratic to n log n to linear.
Bubble sortSwap neighbours that are out of order. After each pass the largest remaining value has floated to the end.O(n²)Selection sortFind the smallest remaining value and put it at the front of the unsorted part. Repeat.O(n²)Insertion sortTake the next value and slide it left into its place among the values already sorted, like sorting cards in your hand.O(n²)Merge sortSplit the array in half, sort each half, then merge the two sorted halves. Divide and conquer.O(n log n)Quick sortPick a pivot, move everything smaller to its left, then sort the two sides the same way.O(n log n) averageCounting sortSort small integers without comparing them: count how many of each value there are, then write them out in order.O(n + k)
Stacks and queues
Last in first out, first in first out, and the monotonic tricks.
Valid parenthesesCheck that every bracket closes in the right order. The textbook use of a stack.O(n)Monotonic stack: next greaterFor every element, find the first larger value to its right, in a single pass.O(n)Evaluate postfix (RPN)Evaluate an expression written with the operator after its operands, such as "3 4 +". No brackets or precedence rules needed.O(n)Queue from two stacksBuild first in, first out behaviour using only two last in, first out stacks.O(1) amortisedSliding window maximum (deque)Report the largest value in every window of size k, using a double-ended queue that keeps only useful candidates.O(n)
Linked lists
Pointer rewiring and the fast and slow runner.
Reverse a linked listFlip every next pointer so the list runs the other way, using three references and no extra memory.O(n)Middle of a list: fast and slowFind the middle node in one pass with two references moving at different speeds.O(n)Cycle detection (Floyd's)Decide whether a linked list loops back on itself, without storing the nodes you have visited.O(n)Merge two sorted listsWeave two sorted lists into one sorted list by always taking the smaller head.O(m + n)Remove the n-th node from the endDelete a node counted from the back in a single pass, by keeping two references a fixed distance apart.O(n)
Trees
Binary search trees, the DFS orders, and level order.
Binary search tree: insertBuild a BST one key at a time. Smaller keys go left, larger keys go right.O(h)Binary search tree: searchLook up a key by walking down from the root, discarding a whole subtree at every step.O(h)Inorder traversalLeft subtree, then the node, then the right subtree. On a BST this yields the keys in sorted order.O(n)Preorder traversalThe node first, then its left subtree, then its right subtree. Parents always come before their children.O(n)Postorder traversalBoth subtrees first, then the node. Children are always finished before their parent.O(n)Level order traversal (BFS)Visit the tree level by level, left to right, using a queue.O(n)Height of a treeThe number of nodes on the longest path from the root down to a leaf, computed bottom-up.O(n)Lowest common ancestor in a BSTFind the deepest node that has both given keys beneath it (or is one of them).O(h)
Heaps
Priority queues: always know the smallest or largest item.
Min-heap: insert and sift upA heap is a complete binary tree stored in an array, where every parent is smaller than its children.O(log n) per insertHeap sortTurn the array into a max-heap, then repeatedly move the largest value to the end.O(n log n)K-th largest elementFind the k-th largest value without sorting everything, by keeping only the k biggest values seen so far.O(n log k)
Graphs
Traversal, shortest paths, ordering and spanning trees.
Breadth-first searchExplore a graph in rings: all neighbours first, then their neighbours. Finds shortest paths when every edge costs the same.O(V + E)Depth-first searchFollow one path as far as it goes, then back up and try the next branch.O(V + E)Dijkstra's shortest pathShortest distance from one node to every other node when edges have non-negative weights.O((V + E) log V)Topological sort (Kahn's)Order the nodes of a directed graph so every arrow points forward. Think build steps or course prerequisites.O(V + E)Kruskal's minimum spanning treeConnect every node with the cheapest possible set of edges. Uses union-find to avoid cycles.O(E log E)Number of islands (flood fill)Count groups of connected land cells in a grid. A grid is a graph where each cell links to its four neighbours.O(rows × cols)
Backtracking
Try a choice, recurse, undo it, try the next.
Dynamic programming
Solve each subproblem once and reuse the answer.
Climbing stairsCount the ways to climb n steps taking 1 or 2 at a time. The gentlest introduction to DP.O(n)House robberPick values from a row so that no two picks are next to each other, and the total is as large as possible.O(n)Coin changeFewest coins needed to make an amount. A case where the greedy choice gives the wrong answer.O(amount × coins)Longest increasing subsequenceThe longest run of values that keeps rising, where you may skip elements but not reorder them.O(n²)Longest common subsequenceLength of the longest sequence of characters that appears in both strings in the same order. The core of diff tools.O(m × n)Edit distanceThe fewest single-character inserts, deletes and replacements needed to turn one string into another.O(m × n)0/1 knapsackChoose items with weights and values to maximise total value without exceeding a weight limit. Each item is used at most once.O(n × capacity)Unique paths in a gridCount the routes from the top-left to the bottom-right corner when you may only move right or down.O(rows × cols)
Bit manipulation
Working directly with the binary form of a number.
C# concepts
How the language and runtime behave: memory, strings, LINQ, async and collections.
Value types and reference typesAssigning a struct copies the data. Assigning a class instance copies only the reference to it.copy: O(size)Boxing and unboxingStoring a value type in an object variable wraps a copy of it in a heap object. Reading it back copies it out again.O(1) plus an allocationPassing by value, ref and outBy default a method gets a copy of the argument. ref and out hand over the caller's variable itself.O(1)String immutability and StringBuilderA string can never be changed after it is created. "Modifying" one always builds a new string.s += x is O(n)Closures and the loop variable trapA lambda captures the variable, not the value it had at that moment. In a for loop that surprises almost everyone once.O(n)LINQ deferred executionA LINQ query is a recipe, not a result. It runs each time you enumerate it, against the data as it is then.runs on enumerationasync and awaitawait does not block the thread. It pauses the method, hands control back to the caller, and resumes when the work finishes.non-blockingHow List<T> growsA List<T> is an array with spare room. When the room runs out it allocates an array twice as big and copies everything across.Add is O(1) amortisedInside a Dictionary: buckets and collisionsA dictionary turns the key into a number, uses that number to choose a bucket, and only searches inside that one bucket.O(1) averagetry, catch and finallyFollow the path through a try block when the code succeeds and when it throws.O(1)Iterators and yield returnA method with yield return produces its values one at a time, pausing between them until the caller asks for the next.O(1) per itemIQueryable vs IEnumerable in EF CoreWith IQueryable, EF Core can send the filter and limit to SQL. After ToList, the same LINQ operators run in memory.depends on query planCancellationToken and async requestsCancellation is a signal the operation must observe. Passing a token to async I/O lets the caller request that work stop.cooperative
OOP concepts
Classes, encapsulation, inheritance, polymorphism and interfaces, shown as running code.
Classes and objectsA class is a blueprint. Each new creates a separate object with its own copy of the fields.new is O(1)EncapsulationKeep the data private and let the outside world change it only through methods that enforce the rules.O(1)Inheritance and constructor orderA derived class gets everything its base class has and adds its own. The base part is always built first.O(1)Polymorphism: virtual and overrideThe same call, s.Area(), runs different code depending on what kind of object s actually is.O(1) per callAbstraction with interfacesDepend on what something can do, not on what it is. Then the implementation can be swapped without touching the caller.O(1)Method overloadingSeveral methods can share a name if their parameter lists differ. The compiler picks one from the argument types.resolved at compile timeStatic and instance membersAn instance field exists once per object. A static field exists once for the whole class and is shared by every object.O(1)override versus new (method hiding)A favourite interview question: what prints when a derived object is used through a base-type variable?O(1)
Design patterns
Reusable ways to structure object creation, data access and interchangeable behaviour.
Repository pattern: separate data accessA service asks an interface for data. The repository hides where that data comes from, so the service does not depend on a database or a list.depends on storageFactory pattern: centralise object creationThe caller asks a factory for an interface. The factory chooses which concrete object to create, keeping construction decisions in one place.O(1) selectionStrategy pattern: swap behaviourPut interchangeable algorithms behind one interface. A context delegates to the selected strategy instead of branching through a growing switch.O(1) per calculation
SOLID principles
Five design principles for keeping object-oriented code easier to change and test.
Single Responsibility: one reason to changeKeep calculation and persistence in separate roles so a change to storage does not affect pricing rules.O(1) per calculationOpen/Closed: add rules without editing the calculatorRepresent each discount as a rule. New rules can be added without growing a central switch.O(rules)Liskov Substitution: keep promises of the base typeA subtype must honor the behavior promised by its base type. Model capabilities explicitly when they vary.O(1) callInterface Segregation: small contracts for real capabilitiesSplit a broad interface into focused capabilities so each type only promises what it can actually do.O(1) callDependency Inversion: depend on a contractKeep business policy pointed at an abstraction; let replaceable infrastructure implement that abstraction.O(1) dispatch