The picture is the data.

Walk every element left to right.

Insert into an Array

Open a gap, then drop the value in.

Delete from an Array

Remove one, and watch the gap close.

Reverse an Array

Two pointers walk inward, trading ends.

Rotate an Array

Shift every element left by k — with three reversals.

Dutch National Flag

Sort 0s, 1s and 2s in a single pass, three pointers.

Prefix Sum

Turn an array into running totals — in place.

Kadane's Algorithm

Find the largest-sum contiguous subarray in one pass.

Sliding Window (Max Sum)

Slide a fixed window to find the largest sum of k in a row.

Move Zeroes

Push every zero to the end, keeping order — in place.

text_fields

Strings

Text is a sequence of characters — scan it, reverse it, test it.

Palindrome Check

Two pointers close in — do the ends always match?

Reverse a String

Swap the ends inward until the whole word flips.

Searching

Find a value or a pair — scan, halve the range, or converge.

Linear Search

Check each element until the key turns up.

Binary Search

Halve the range each step — discard the half that can’t hold the key.

time O(log n) space O(1)

Two Sum (Sorted)

Two pointers close in from both ends to hit the target.

sort

Sorting

Bring order out of chaos — from simple swaps to merge & heap.

Bubble Sort

Adjacent swaps float the biggest value to the end each pass.

time O(n²) space O(1)

Selection Sort

Find the smallest, send it to the front, repeat.

time O(n²) space O(1)

Insertion Sort

Grow a sorted prefix; slide each new value back into place.

time O(n²) space O(1)

Merge Sort

time O(n log n) space O(n)

Split to single elements, then merge halves through a buffer.

Quick Sort

time O(n log n) avg space O(log n)

Partition around a pivot, then recurse on each side.

Heap Sort

time O(n log n) space O(1)

Build a max-heap in the array, then pull the max to the end, repeat.

Counting Sort

time O(n + k) space O(n + k)

Tally each value, then place them all in order — no comparisons.

Radix Sort

time O(d · (n + b)) space O(n + b)

Stably sort by each digit, least-significant first.

layers

Stacks & Queues

Order of arrival — last in first out, or first in first out.

Stack — Push & Pop

time O(1) per op space O(n)

Last in, first out — everything happens at the top.

Queue — Enqueue & Dequeue

time O(1) amortised space O(n)

First in, first out — join at the back, leave from the front.

Monotonic Stack — Next Greater

One pass, one stack: find each value’s next greater neighbour.

time O(n) space O(n)

link

Linked Lists

Nodes joined by pointers — rewire instead of shifting.

Traverse a Linked List

Follow next pointers from head to ∅.

Insert into a Linked List

time O(1) at a known node space O(1)

Rewire two pointers — nothing shifts.

Delete from a Linked List

time O(1) at a known node space O(1)

Point past the node — it simply drops out of the chain.

Reverse a Linked List

Move each node, one at a time, to the front of a new list.

tag

Hashing

Turn a key into a slot — and handle the collisions.

Hash Table — Linear Probing

time O(1) average space O(m)

h(k) picks a slot; if it’s taken, walk forward until one is free.

Hash Table — Chaining

time O(1) average space O(n + m)

Every bucket holds a little list; collisions just grow a chain.

account_tree

Trees

Branching structure — search trees, traversals and heaps.

BST — Insert

Smaller keys go left, larger go right — every key finds one path.

time O(h) space O(1)

BST — Search

One comparison per level throws away half the tree.

time O(h) space O(1)

In-order Traversal

Left, node, right — and the keys come out sorted.

time O(n) space O(h)

BST — Delete

Leaf, one child, or two — the third case needs a successor.

time O(h) space O(1)

Build a Max-Heap

Sift every parent down until each one outranks its children.

Heap — Extract Max

Take the root, move the last node up, and sink it back down.

time O(log n) space O(1)

hub

Graphs

A web of nodes and edges — traverse it, order it, find the cheapest way.

Breadth-First Search

Explore ring by ring, using a queue.

time O(V + E) space O(V)

Depth-First Search

Follow one path as deep as it goes, then back up.

time O(V + E) space O(V)

Topological Sort

Order tasks so every arrow points forward.

time O(V + E) space O(V)

Dijkstra’s Shortest Path

time O(E log V) space O(V)

Always expand the closest unsettled node.

Minimum Spanning Tree (Kruskal)

time O(E log E) space O(V)

Take the cheapest edge that doesn’t close a cycle.

schema

Recursion & DP

Branch and backtrack — then stop repeating yourself with a table.

Recursion — Fibonacci Call Tree

Watch the same subproblem get solved again and again.

time O(2ⁿ) space O(n)

Backtracking — All Subsets

Every element: take it or leave it. Each path spells a subset.

time O(2ⁿ) space O(n)

Backtracking — N-Queens

Place a queen per row; retreat the moment it cannot work.

time O(n!) space O(n)

DP — Fibonacci Table

The same answer in n steps instead of 2ⁿ calls.

time O(n) space O(n)

DP — Coin Change

time O(amount × coins) space O(amount)

Fewest coins for every amount up to the target.

DP — Longest Increasing Subsequence

For each element, the best chain that ends there.

time O(n²) space O(n)

DP — Edit Distance