Algorithms

To appreciate quantum speedup you need to understand classical complexity first. Without knowing that unstructured search is O(N) classically, Grover’s O(√N) speedup is just a number. Without knowing that no polynomial-time classical algorithm exists for integer factorisation, Shor’s algorithm loses its significance. This course covers algorithm design, Big-O notation, search, sorting, graph algorithms, and computational complexity - the essential context for studying what quantum computers actually do better.

What you’ll learn

• Big-O notation: how to describe algorithm efficiency and why constants are dropped
• Time and space complexity: working out the asymptotic behaviour of real algorithms
• Classical search: linear search O(N), binary search O(log N) - and the gap that makes Grover’s algorithm impressive
• Sorting algorithms: bubble sort O(N²), merge sort O(N log N), quicksort - when each is optimal
• Data structures: arrays, linked lists, hash tables, binary trees, and which problems each solves efficiently
• Graph traversal: BFS and DFS on adjacency lists and matrices
• Shortest path algorithms: Dijkstra’s algorithm for weighted graphs
• Dynamic programming: overlapping subproblems, memoisation, and classic DP problems
• Computational complexity classes: P (efficiently solvable) and NP (efficiently verifiable)
• NP-completeness: why some problems are believed to be fundamentally hard
• The P vs NP question: what quantum computers do and do not change about it

Course structure

Brilliant structures this as a progressive learning path. Every concept is introduced through an interactive problem before the formal definition appears.

The course begins with algorithm analysis basics: given two algorithms for the same problem, how do you compare them rigorously? Big-O notation emerges from this question. Data structures follow, because efficient algorithms depend on the right underlying structure. Sorting algorithms occupy a substantial section - you trace through merge sort and quicksort step by step, predicting each comparison before it executes.

Graph algorithms come next: BFS and DFS are visualised on interactive graphs you manipulate. Dijkstra’s shortest path algorithm follows as a natural extension.

Dynamic programming is the most challenging topic and receives the most coverage. Classic problems including longest common subsequence and coin change are used as worked examples. The course closes with complexity theory: P, NP, NP-completeness, and why quantum computers do not simply solve all hard problems faster.

Who is this for?

• Quantum computing students who want to understand why specific algorithms are impressive
• Self-learners who went directly into quantum content and need stronger CS foundations
• Software developers who write production code but never studied complexity formally
• Physicists or mathematicians moving into quantum computing who have maths but not CS
• Anyone taking a Delft edX or Coursera quantum course who wants to follow the algorithm analysis sections properly

Prerequisites

Secondary school mathematics is all that is strictly required. You do not need programming experience - Brilliant presents algorithms in visual, animated pseudocode rather than code. No prior study of algorithms or computer science is assumed. If you can follow a recipe step by step and notice when a step is out of order, you have the prerequisites.

Hands-on practice

Every section uses Brilliant’s interactive problem format. You do not watch someone sort an array - you sort it yourself, step by step, predicting each comparison before it is revealed. You do not watch BFS traverse a graph - you choose which node to visit next and see the frontier expand in real time.

Complexity analysis problems give you algorithm sketches and ask you to determine the Big-O before the answer appears. The entire course runs in the browser with no installation. Problems take five to ten minutes each, making daily study sessions practical on any device including mobile.

Why take this course?

The quantum speedup story only makes sense with classical complexity as a reference point.

Grover’s search provides a quadratic speedup over O(N) classical unstructured search. Without knowing the O(N) lower bound, the speedup is just a number. Knowing the lower bound makes Grover’s O(√N) genuinely remarkable.

Shor’s factoring algorithm runs in polynomial time on a quantum computer. The significance is that no polynomial-time classical algorithm is known for factorisation. Without knowing what classical complexity says about factoring, Shor’s algorithm sounds like a minor improvement rather than a revolution.

Brilliant’s interactive format is faster than a textbook and more engaging than lectures. If your goal is to reach Grover’s or Shor’s with real understanding of why they matter, this is the right prerequisite to complete first.

Related tutorials

Practise the concepts from this course with these hands-on tutorials:

• Grover’s Algorithm Explained - Step-by-step implementation of Grover’s search algorithm in Qiskit
• Shor’s Algorithm Explained - How Shor’s factoring algorithm works and why it threatens current encryption