History of Algorithms
The Art of Computation

Euclid's Algorithm

The oldest known algorithm – a method for computing the greatest common divisor (GCD). It appears in Euclid's Elements and is still used in modern cryptography.

# Euclid's algorithm (Python)
def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a

Sieve of Eratosthenes

An efficient algorithm to find all prime numbers up to a given limit. It remains one of the most elegant and widely taught algorithms.

# Sieve of Eratosthenes
def sieve(n):
    primes = [True] * (n+1)
    primes[0] = primes[1] = False
    for i in range(2, int(n**0.5)+1):
        if primes[i]:
            for j in range(i*i, n+1, i):
                primes[j] = False
    return [i for i, p in enumerate(primes) if p]

Al-Khwarizmi's Arithmetic

The Persian mathematician introduced the decimal positional number system and the algorithms for addition, subtraction, multiplication, and division. The word "algorithm" derives from his name.

Legacy His work laid the foundation for modern algebra and algorithmic thinking.

Fibonacci's Liber Abaci

Introduced the Hindu–Arabic numeral system to Europe and described the famous Fibonacci sequence, which has recursive algorithmic properties.

# Recursive Fibonacci
def fib(n):
    if n <= 1: return n
    return fib(n-1) + fib(n-2)

Newton–Raphson Method

An iterative algorithm for finding successively better approximations to the roots of a real-valued function. It is foundational in numerical analysis.

Eulerian Path – Seven Bridges of Königsberg

Leonhard Euler's solution to the Königsberg bridge problem laid the groundwork for graph theory and algorithmic graph traversal.

Fast Fourier Transform (FFT)

Gauss developed the FFT, but it was later popularised by Cooley and Tukey. It revolutionised signal processing and digital communication.

Babbage's Analytical Engine

Charles Babbage designed the first general-purpose computer, with algorithms stored on punched cards. Ada Lovelace wrote the first algorithm intended for implementation on a machine.

Merge Sort – John von Neumann

The first recursive sorting algorithm. It uses divide-and-conquer to achieve O(n log n) time complexity, and remains a fundamental algorithm in computer science.

# Merge sort (conceptual)
def merge_sort(arr):
    if len(arr) <= 1: return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

Dijkstra's Algorithm

Edsger Dijkstra's algorithm for finding the shortest path in a graph is the backbone of modern navigation systems.

Quicksort – Tony Hoare

One of the most widely used sorting algorithms, with average-case O(n log n). It uses a pivot and partitioning, and is a classic example of randomised algorithms.

RSA Cryptosystem

Rivest, Shamir, and Adleman invented the first public-key cryptography algorithm, enabling secure communication over insecure channels. Based on the difficulty of factoring large integers.

Simulated Annealing

A probabilistic optimisation algorithm inspired by metallurgy. Used in many fields to find approximate solutions to complex problems.

Backpropagation (popularised)

The algorithm that made deep learning possible – it efficiently computes gradients in neural networks. It enabled the AI revolution.

Shor's Algorithm

A quantum algorithm that factors integers exponentially faster than classical algorithms, threatening RSA cryptography.

Grover's Algorithm

Provides a quadratic speedup for unstructured search, one of the foundational quantum algorithms.

Deep Blue – IBM

The first computer to defeat a reigning world chess champion (Garry Kasparov). It used a brute-force search algorithm with extensive pruning.

PageRank – Google

Larry Page and Sergey Brin's algorithm transformed the web by ranking pages based on link structure – the heart of Google's early success.

AlexNet – Convolutional Neural Networks

AlexNet won the ImageNet competition, kickstarting the deep learning revolution. Its algorithm – backpropagation with GPU acceleration – became the standard for image recognition.

AlphaGo – DeepMind

The first AI to defeat a world champion in the board game Go. It combined Monte Carlo Tree Search with deep neural networks, demonstrating the power of reinforcement learning.

Transformer Architecture

The "Attention Is All You Need" paper introduced the Transformer, which underpins GPT, BERT, and modern large language models.

Quantum Supremacy – Google

Google's Sycamore processor performed a calculation in 200 seconds that would take the world's fastest supercomputer thousands of years. Quantum algorithms are rewriting the limits of computation.

GPT-4 & Large Language Models

Transformer-based models achieved human-level performance on many reasoning tasks, demonstrating the power of scale and attention mechanisms.

Future of Algorithms

Quantum algorithms, neuromorphic computing, and bio-inspired algorithms promise to solve problems that are intractable today. The history of algorithms is still being written.