You've probably heard the word "algorithm" thrown around in tech news, social media debates, and computer science classes. But what actually is an algorithm?

The answer is simpler than you might think.

The Definition

An algorithm is a step-by-step procedure for solving a problem. That's it.

A recipe is an algorithm. Driving directions are an algorithm. The method you use to find a word in a dictionary is an algorithm.

More precisely, an algorithm has these properties:

Input: It takes some data to work with
Output: It produces a result
Definiteness: Each step is precisely defined
Finiteness: It terminates after a finite number of steps
Effectiveness: Each step is simple enough to be carried out

A Real-World Example

Here's an algorithm you already use — finding the smallest number in a list:

1. Assume the first number is the smallest
2. Look at the next number
3. If it's smaller than your current smallest, remember it instead
4. Repeat steps 2-3 until you've checked every number
5. The number you remembered is the smallest

For the list [34, 12, 45, 7, 23]:

Start: smallest = 34
Check 12: 12 < 34, so smallest = 12
Check 45: 45 > 12, no change
Check 7: 7 < 12, so smallest = 7
Check 23: 23 > 7, no change
Answer: 7

That's an algorithm. Simple, unambiguous, and guaranteed to find the answer.

Why Do Algorithms Matter?

Every program you've ever used is built on algorithms. When you:

Search Google: An algorithm ranks billions of web pages in milliseconds
Use GPS navigation: An algorithm finds the shortest route through thousands of roads
Sort your email: An algorithm organizes messages by date, sender, or subject
Stream music: An algorithm compresses audio files so they load quickly
Scroll social media: An algorithm decides what content to show you

The difference between a good algorithm and a bad one can be the difference between a program that runs in seconds and one that takes years.

Measuring Algorithms: Big O Notation

Not all algorithms are created equal. Computer scientists use Big O notation to describe how an algorithm's performance scales with input size:

| Notation | Name | Example | Speed | |----------|------|---------|-------| | O(1) | Constant | Looking up an array element by index | Instant | | O(log n) | Logarithmic | Binary search in a sorted list | Very fast | | O(n) | Linear | Finding the minimum in an unsorted list | Fast | | O(n log n) | Linearithmic | Merge sort, quick sort | Good | | O(n²) | Quadratic | Bubble sort, selection sort | Slow | | O(2ⁿ) | Exponential | Brute-force password cracking | Very slow |

For 1 million items:

O(n log n) does ~20 million operations
O(n²) does 1 trillion operations

That's the difference between finishing in seconds and running for days.

Common Algorithm Categories

Sorting Algorithms

Sorting is the most studied problem in computer science. Given an unsorted list, arrange it in order. Different algorithms use different strategies:

Bubble Sort repeatedly compares adjacent elements and swaps them if they're out of order. Simple but slow — O(n²).

Quick Sort picks a "pivot" element and partitions the list around it, then recursively sorts each half. Fast on average — O(n log n).

Merge Sort splits the list in half, sorts each half, then merges the sorted halves back together. Consistent O(n log n) performance.

Each algorithm has trade-offs in speed, memory usage, and simplicity. Our sorting visualizations let you watch each one in action, side by side.

Searching Algorithms

Finding a specific item in a collection:

Linear Search: Check each element one by one. Works on any list but slow — O(n).

Binary Search: If the list is sorted, check the middle, then eliminate half the list. Blazingly fast — O(log n). Searching 1 billion items takes only 30 steps!

Graph Algorithms

Finding paths, connections, and relationships:

Dijkstra's Algorithm finds the shortest path between two points in a network — how GPS works.

Breadth-First Search explores all neighbors before going deeper — used for finding the shortest route in an unweighted graph.

Dynamic Programming

Breaking complex problems into simpler subproblems, solving each once, and storing the results:

Fibonacci Sequence can be computed efficiently by storing previously calculated values instead of recalculating them.

Knapsack Problem — given items with weights and values, what's the most valuable combination that fits in your bag?

Algorithms in AI

Modern AI is built on algorithms too:

Gradient Descent optimizes neural network weights by following the steepest path downhill on the loss surface
Backpropagation efficiently computes how to adjust each weight in a neural network
Attention Mechanisms allow transformer models to focus on relevant parts of the input

The difference is that these algorithms don't solve problems directly — they learn from data how to solve problems.

How to Think Algorithmically

Algorithmic thinking is a skill that goes beyond programming:

Break the problem down into smaller, manageable steps
Look for patterns — can you reuse a solution for part of the problem?
Consider edge cases — what happens with empty input? One element? Already sorted?
Analyze trade-offs — faster algorithms often use more memory, and vice versa
Start simple — get a working solution first, then optimize

See Algorithms in Action

The best way to build algorithmic intuition is to watch algorithms work. Our interactive visualizations let you:

Step through sorting algorithms one comparison at a time
Watch how different algorithms handle the same data differently
See the actual code execute alongside the visualization
Compare performance metrics in real-time

Whether you're studying for a CS class, preparing for coding interviews, or just curious, seeing algorithms visually makes abstract concepts click.