Topics

A function that solves a problem by calling itself on a smaller version of the same problem.

Values stored side by side in memory, so any position can be reached directly by its index.

Two ways to hold items in order: a stack gives back the newest item first, a queue the oldest.

A chain of nodes where each one holds a value and a pointer to the next, so items can be added without shifting anything.

Store values under keys, using a hash of each key to jump straight to where it lives.

A tree where every node's left side holds smaller values and its right side holds larger ones, so a search can skip half the tree at each step.

A tree where every parent is smaller than its children, kept in an array, so the minimum is always at the front.

A way to describe how an algorithm's work grows as its input grows, ignoring constant factors.

Find a value in a sorted list by checking the middle and throwing away the half it can't be in.

Walk the list swapping neighbours that are out of order; each pass carries the largest remaining value to the end.

Grow a sorted section at the front, sliding each new value left until it fits.

Split the list in half, sort each half, then merge the two sorted halves into one.

Pick a pivot, move every smaller value to its left, then sort each side the same way.

No sort is fastest everywhere. The best choice depends on the input's size and order, and on whether you need stability or little memory.

Visit every node you can reach from a start node, using a queue to go wide first or a stack to go deep first.

Find the shortest distance from one node to every other by always settling the closest node not yet settled.

Two places a running program keeps data: the stack holds each call's own variables and is freed when the call returns; the heap holds data that has to outlive a call.

A reference (or pointer) is a value that says where some data lives instead of holding the data itself, so two variables can share one object.

Automatic memory management that finds objects the program can no longer reach and frees them, so you never call free yourself.

A way to write code that waits (for the network, a disk, a timer) without blocking: await pauses the function and lets other work run until the result is ready.

A bug where the result depends on the timing of threads or tasks that share data, so the same code is right on one run and wrong on the next.