Graph Algorithms with Rust

This course is part of Rust for Data Engineering Specialization

Instructor: Noah Gift

Access provided by Ludwig-Maximilians-Universität München (LMU)

5 modules

Gain insight into a topic and learn the fundamentals.

Intermediate level

Recommended experience

3 hours to complete

Flexible schedule

Learn at your own pace

5 modules

Gain insight into a topic and learn the fundamentals.

Intermediate level

Recommended experience

3 hours to complete

Flexible schedule

Learn at your own pace

What you'll learn

Implement BFS, DFS, Dijkstra, PageRank, and Kosaraju strongly-connected components from scratch in Rust using petgraph and aprender-graph
Apply each algorithm to a real dataset: a Lisbon walking-route graph, a sports link graph, UFC fight records, and a Twitter follower graph
Ship a clap-based command-line tool that exposes every algorithm as a subcommand and emits machine-readable JSON

Skills you'll gain

Tools you'll learn

Details to know

Shareable certificate

Add to your LinkedIn profile

Assessments

5 assignments

Taught in English

See how employees at top companies are mastering in-demand skills

Learn more about Coursera for Business

logos of Petrobras, TATA, Danone, Capgemini, P&G and L'Oreal

Build your subject-matter expertise

This course is part of the Rust for Data Engineering Specialization

When you enroll in this course, you'll also be enrolled in this Specialization.

Learn new concepts from industry experts
Gain a foundational understanding of a subject or tool
Develop job-relevant skills with hands-on projects
Earn a shareable career certificate

There are 5 modules in this course

Graph Algorithms with Rust teaches you to model real datasets as graphs and run the classical algorithms — BFS, DFS, Dijkstra, PageRank, and Kosaraju strongly-connected components — in cache-friendly Rust. Across five modules you walk through the same problems data engineers actually solve: loading edge lists into a graph, finding the shortest walking route between Lisbon landmarks, ranking sports websites by PageRank, scoring UFC fighters by centrality, and detecting communities in a Twitter-style follower graph.

You use both the textbook petgraph crate and the benchmarked aprender-graph crate, so you see two production-tested ways to model the same problem. Every algorithm comes with a runtime contract — provable assertions like "PageRank scores must sum to 1.0" — so the demos catch silent regressions, not just compile errors. The course closes with a working clap-based CLI tool that wires every algorithm together behind subcommands and emits machine-readable JSON, ready to ship as a single static binary. By the end you can pick the right algorithm for a real graph problem and ship it as a tested Rust binary.

Build the foundations of working with graph data in Rust. You will learn how property graphs differ from relational models, set up a connection to Amazon Neptune using openCypher, and design a clean repository pattern that separates query logic from application code. By the end of this module, you will have a working Rust project that can connect to Neptune and execute basic graph queries.

What's included

3 videos3 readings1 assignment

Move beyond simple lookups to learn how graph traversal really works. You will implement breadth-first and depth-first search in Rust, run shortest-path queries with Dijkstra and A* against Neptune, and reason about the trade-offs between recursive Cypher and client-side traversal. By the end of this module, you will be able to choose the right traversal strategy for a given problem and implement it in production-quality Rust.

What's included

3 videos2 readings1 assignment

Learn how to identify the most important nodes in a graph. You will compute degree, betweenness, and closeness centrality, then implement PageRank from scratch using power iteration over an eigenvector formulation. By the end of this module, you will be able to rank nodes by influence in real-world networks and explain the linear algebra that makes PageRank work.

What's included

4 videos2 readings1 assignment

Discover the structure hidden inside large, messy graphs. You will implement Tarjan's and Kosaraju's algorithms for strongly connected components, then apply Louvain modularity to find communities in undirected networks. By the end of this module, you will be able to decompose a real-world graph into its meaningful subgroups and explain what those subgroups reveal about the system being modeled.

What's included

2 readings1 assignment

Take everything you have built and ship it as a real tool. You will design a robust command-line interface in Rust, add structured logging and error handling, integrate with CI, and package the binary for distribution. By the end of this module, you will have a production-ready Rust CLI that runs graph algorithms against Neptune from your terminal and is ready to hand off to a team.