Data structures and algorithms are essential if you want to write efficient code, which is why they’re a fundamental part of technical interviews.

In this Best Courses Guide (BCG), I’ve leveraged Class Central’s catalog of 200K courses and the internet to find the best data structure and algorithm courses available online.

Click on the shortcuts for more details:

• Top Picks
• What are Data Structures and Algorithms?
• Why You Should Trust Us
• Courses Overview
• How We Made Our Picks and Tested Them

Here are my top picks. Click to skip to the course details:

Related Guides

• Java
• Python
• C++
• JavaScript
• SAS

Recommended

• MATLAB
• Data Analysis
• Data Science
• Scala
• C Programming

Trending Guides

• Arduino
• Drawing
• American Sign Language (ASL)
• SQL
• Blender

What are Data Structures and Algorithms?

Data structures and algorithms are everywhere, and there is a good reason for that. Data structures help us hold data and provide affordances for efficiently accessing it, while algorithms represent tried and tested computational recipes to accomplish particular goals. Let me explain how it all works.

Human thinking may seem flexible and seemingly unconstrained, but in truth, we have a flurry of biological limitations. For instance, we typically can only hold in our short-term memory about 7 items — the famous magical number 7.

Well, computers have similar limitations too. They have limited resources that constrain what can be accomplished with software in a number of ways: computers can only store so much data in memory, and computers can only perform so many operations per second — most notably, CPUs.

That said, there are many ways of taking advantage of computer resources, some more efficient than others. Data structures in particular, as their name suggests, allow to organize information in such a way that it can efficiently be leveraged in certain contexts. There are many data structures, each with their strengths and weaknesses. A good developer should know the fundamental data structures and when to use each. They’re essential components of many applications, and they’re ubiquitous in high-performance computing.

An algorithm is a series of step-by-step instructions that end in achieving a desired result. They’re a general method for tackling similar problems. For example, find a name in a sorted list of names, or find the shortest path between two nodes in a graph.

Data structure and algorithms often work hand-in-hand. A particular algorithm typically leverages a particular data structure. Well thought out combinations of algorithms and data structures can help minimize the running time and memory needed to perform a certain operation, thus saving a lot of time and money in the process.

Having a wide arsenal of data structures and algorithms at your disposal grants you the freedom to choose the most appropriate solution to code whatever you want.

Another major reason why you should learn data structures and algorithms is that many of the giant tech companies like, Microsoft, and Google include it as part of their interviews. During technical interviews, you’ll be asked to solve computing problems that don’t simply involve picking an appropriate data structure or algorithm but also implementing them and showing the interviewer that you indeed understand the intuition behind the process.

Why You Should Trust Us

Class Central, a Tripadvisor for online education, has helped 60 million learners find their next course. We’ve been combing through online education for more than a decade to aggregate a catalog of 200,000 online courses and 200,000 reviews written by our users. And we’re online learners ourselves: combined, the Class Central team has completed over 400 online courses, including online degrees.

Courses Overview

• Combined, the courses have over 10M enrollments and views
• 9 of the courses are free or free-to-audit, whereas 2 are paid
• About 216K+ students are following the Algorithms and Data Structures Subject on Class Central.

Now that the data nerds have been satisfied, let’s get to the top picks!

Best Overall Free Java Course That Covers all You Need to Know (Princeton University)

If you have some familiarity with Java, including loops, arrays, functions, recursion, and objects, as well as high-school algebra, Algorithms, Part I is a great course. It includes interactive quizzes and 5 lengthy coding assignments. The course also provides a few algorithmic job interview questions based on the material for the week which are inspired by questions asked at leading technology companies.

This course touches on elementary data structures, sorting, and searching algorithms. It covers the essential information that every serious programmer needs to know about algorithms and data structures, with emphasis on applications and scientific performance analysis of Java implementations.

What you’ll learn:

• Data types:
  • Union-find (dynamic connectivity problem)
  • Stack and queue (implemented with linked lists or resizing arrays)
  • Priority queue (implemented with binary heap)
• Sorting algorithms:
  • Elementary: selection sort, insertion sort
  • Advanced: mergesort, quicksort, heapsort
  • Shuffling algorithms
  • Radix sorts
• Searching algorithms:
  • Symbol tables (logarithmic performance)
  • Hash tables and hash functions (constant-time performance)
• Applications covered:
  • Parsing arithmetic expressions
  • Simulating queueing systems
  • Simulating particle motion.

The next part of the course is Algorithms, Part II, focusing on graph-processing and string-processing algorithms, as well as reductions and intractability. This course can also be accompanied by the free online book Algorithms, 4th Edition, of which the instructors are co-authors.

Best Language-Agnostic Course That Isn’t Afraid of Math (Stanford University)

In Algorithms: Design and Analysis, Part 1 you will learn several fundamental principles of algorithm design and the data structures they rely on. This course is demanding but rewarding. My colleague @dhawal wrote about it here.

It emphasizes the big picture and conceptual understanding over low-level implementation and mathematical details. By the end of the course, you’ll be well-positioned to ace your technical interviews and speak fluently about algorithms with other programmers and computer scientists.

The prerequisites of this free-to-audit course include basic programming experience in any programming language and some knowledge of mathematical proofs (proof by induction, proof by contradiction, etc).

What you’ll learn:

• Introduction to algorithms (integer multiplication example)
• Merge Sort, Quick Sort
• Big O notation
• Divide-and-conquer paradigm
• Recurrence solving
• Quick Select algorithm
• Graph theory and representation
• Graph search and Dijkstra’s shortest-path algorithm
• Transforming failing algorithms to succeeding ones
• Data structures: heaps, binary search trees, hash tables, operations and running times, problem-solving applications.

The course contains optional free lectures that dive deeper into the theory behind the algorithms you’ve learnt, if you’d like to satisfy your intellectual hunger.

Paying learners can access 6 multiple-choice quizzes to test your understanding, and 6 programming assignments, where you’ll implement one of the algorithms covered in the lectures in any programming language you want.

The next course you should take after this is Algorithms: Design and Analysis, Part 2.

Tim Roughgarden is the Professor of Computer Science and member of the Data Science Institute at Columbia University. He received the Gödel Prize in 2012 for his work on routing traffic in large-scale communication networks to optimize performance of a congested network.

Best Python Course for Beginners Who are Shaky with Math (Treehouse)

An excellent course for beginners is Algorithms and Data Structures Tutorial offered by Treehouse on freeCodeCamp’s YouTube channel. Check out the fCC YouTube community as well.

It teaches you all about algorithms and data structures, giving you the intuition behind each algorithm and data structure while avoiding flooding you with mathematical details. By the end of this free course, you will understand what algorithms and data structures are, how they are implemented and evaluated, and how they are used to solve problems.

What you’ll learn:

• Algorithms introduction: definition and real-world applications, example: “Guess the number” game
• Search algorithms: linear search, binary search (including recursive implementation)
• Time complexity: Big O notation, types: linear, quadratic, quasilinear, exponential
• Space complexity
• Data structures: arrays: operations and characteristics, linked lists: operations and comparison with arrays
• Sorting algorithms: bogosort,quicksort, merge sort (including application to linked lists)
• Implementation: coding algorithms in Python, measuring Big-O runtime in Python
• Real-world applications of algorithms.

Follow along while the instructor codes to further cement your understanding.

Treehouse offers many other programming courses on their website. Pasan is a iOS, Swift and Computer Science teacher at Treehouse, while Jay is the author of Head First Ruby and Head first Go, both published by O’Reilly Media.

Rigorous but Rewarding Python Course if You Want a Challenge (Massachusetts Institute of Technology)

6.006 Introduction to Algorithms is a free introduction to mathematical modeling of computational problems. It is demanding (as expected from an MIT course) but also rewarding if you’re up for the challenge.

It covers elementary data structures and algorithmic approaches to solve classical problems. The course emphasizes the relationship between algorithms and programming and introduces basic performance measures and analysis techniques for these problems.

To take this course, you’ll need basic experience programming in Python 3 and basic knowledge of discrete mathematics. You can try completing Problem Set 0 to see if this course is right for you.

What you’ll learn:

• Fundamentals: algorithms and Big O notation, data structures
• Sorting and searching: permutation, selection, insertion, and merge sort, binary search, hashing and hash tables, tuple, counting, and radix sort
• Trees: binary trees: terminology, variations, operations, balanced trees (e.g., AVL trees), binary heaps and priority queues
• Graph theory: terminology and representations, breadth-first search vs. depth-first search
• Shortest-path algorithms: Bellman-Ford algorithm, Dijkstra’s algorithm, APSP algorithm, and Johnson algorithm

• Dynamic programming: concept and applications, recursive algorithms (e.g., Fibonacci sequence, coin names), complexity: polynomial and pseudo-polynomial time
• Practical applications: road networks, chess, piano fingering.

The video lectures are uploaded to YouTube. The free course also includes supplemental resources: course notes, course assignments and their solutions.

Erik Demaine is a professor of Computer Science at the Massachusetts Institute of Technology and a former child prodigy. He completed his bachelor’s degree at the age of 14 and completed his PhD by the time he was 20 years old! He is reportedly the youngest professor in the history of MIT.

Best Comprehensive Course with a Focus on Data Science Applications (University of Colorado Boulder)

The Foundations of Data Structures and Algorithms Specialization, released in late 2023, is designed to teach students the fundamental concepts of organizing and manipulating data efficiently in computer systems. The specialization focuses on data science applications and is suitable for learners with basic Python programming skills. It covers various data structures and algorithms essential for processing large amounts of data, including sorting, searching, and indexing.

If you want to take your formal studies further, the specialization is part of CU Boulder’s MS in Data Science and MS in Computer Science programs offered on Coursera. Each course covers specific topics related to data structures and algorithms, progressing from fundamental concepts to more advanced techniques. The courses are designed to be taken in sequence, building upon the knowledge gained in previous modules.

It includes 5 free-to-audit courses where you will learn:

• Course 1: Algorithms for Searching, Sorting, and Indexing: basics of algorithm design and analysis, algorithms for sorting arrays, data structures such as priority queues, hash functions, and applications such as Bloom filters
• Course 2: Trees and Graphs: Basics: basic algorithms on tree data structures, binary search trees, self-balancing trees, graph data structures and basic traversal algorithms on graphs. Advanced topics include kd-trees for spatial data and algorithms for spatial data
• Course 3: Dynamic Programming, Greedy Algorithms: basic algorithm design techniques such as divide and conquer, dynamic programming, and greedy algorithms. Includes a brief introduction to intractability (NP-completeness) and using linear/integer programming solvers for solving optimization problems and some advanced topics in data structures
• Course 4: Approximation Algorithms and Linear Programming: focuses on linear and integer programming formulations to solve algorithmic problems and find optimal solutions such as resource allocation, scheduling, task assignment, and variants of the traveling salesperson problem. Also algorithms for NP-hard problems whose solutions are guaranteed to be within some approximation factor of the best possible solutions. Such algorithms are often quite efficient and provide useful bounds on the optimal solutions
• Course 5: Advanced Data Structures, RSA and Quantum Algorithms: number-theory based cryptography, basics of quantum algorithms and advanced data-structures.

Rigorous Java Course with a Focus on Data Structures (Georgia Institute of Technology)

Data Structures & Algorithms I aims to empower computer scientists in training like you with the actual building blocks to create data structures and algorithms that make programs come alive.

This free-to-audit course provides an overview of basic linear data structures and the algorithms that operate on those structures. By the end of the course, you’ll understand the fundamental principles of linear data structures and you’ll be able to differentiate between those linear structures, implement them efficiently, and analyze their performance. Learn via videos, interactive exercise, and a visualization exploratory lab. This course is part of the Data Structures and Algorithms Professional Certificate and was one of the 100 most popular free online courses in 2022.

The prerequisites for the course are basic knowledge of the Java programming language and object oriented principles.

What you’ll learn:

• Module 1:
  • Java object-oriented design principles
  • Big-O and time complexity
  • Iterator and Iterable
  • Comparable and Comparator

• Module 2: Arrays & ArrayLists
  • Recursion review and application
  • Implementation of recursive methods
  • High-level data structure behavior

• Module 3: Linked Lists
  • Singly-Linked Lists
  • Doubly-Linked Lists
  • Circularly-Linked Lists
  • Iteration and recursion on Linked Lists

• Module 4: Stacks and Queues
  • Fundamental abstract data types
  • Implementation using Arrays and LinkedLists
  • Priority Queues
  • Deques

Mary Hudachek-Buswell is a professor in the Computer Science department at Georgia Institute of Technology.

Language-Agnostic and Highly Practical Course Focused on Algorithms (University of California, San Diego)

Offered by the University of California, San Diego, Algorithmic Toolbox covers the basic algorithmic techniques and ideas for computational problems that come up frequently in everyday applications. It’s super hands on: you’ll implement a ton of algorithms.

You will learn how to sort data and how it helps for searching, how to break a large problem into pieces and solve them recursively, when it makes sense to proceed greedily, and how dynamic programming is used in genomic studies. By practicing solving computational problems, designing new algorithms, and implementing efficient solutions, you’ll become a better programmer.

To take this free-to-audit course, you’ll need basic knowledge of any programming language as well as some topics in discrete mathematics including proof by induction and proof by contradiction.

What you’ll learn:

• Overview of algorithms and data structures, sample programming challenges
• Introduction to algorithms: efficiency comparison, estimating running time and memory needs
• Greedy algorithms: use cases and limitations, proving optimal solutions, application: optimal money changing program
• Divide and Conquer: efficient database searching, fast multiplication techniques, merge sort and quicksort, majority element finding, sorting efficiency proofs
• Dynamic programming: solving optimization problems, applications: TV ad revenue maximization, similar web page search, gene finding, efficient program implementation
• Key skills developed: algorithm selection and analysis, problem-solving techniques, practical programming applications

This course comes with a companion book that contains many solutions (including Python code) and hints for the problems in the course. It is the first course out of six in the Data Structures and Algorithms Specialization.

Great for JS Beginners, with Free Certificate (freeCodeCamp)

Although JavaScript Algorithms and Data Structures is not strictly a DSA course, it does teach you the fundamentals of it. Hence it is also great for anyone interested in web development.

While HTML and CSS control the content and styling of a page, JavaScript is used to make it interactive. In the JavaScript Algorithm and Data Structures Certification, you’ll learn the fundamentals of JavaScript including variables, arrays, objects, loops, and functions.

Once you have the fundamentals down, you’ll apply that knowledge by creating algorithms to manipulate strings, factorialize numbers, and even calculate the orbit of the International Space Station.

So this free course is a great 2-in-1 option: you’ll learn both programming and algorithms/data structures.

What you’ll learn:

• Basic JavaScript: arrays, objects, functions, loops, if/else statements
• ES6 features
• Regular Expressions
• Debugging using JavaScript console
• Basic Data Structures
• Basic Algorithm Scripting
• Object Oriented Programming
• Functional Programming
• Intermediate Algorithm Scripting
• Arrays vs. objects: usage and manipulation
• Methods: splice(), Object.keys()
• Algorithmic thinking and implementation
• Temperature conversion
• Handling 2D arrays
• Summing prime numbers
• Text conversion (e.g., Pig Latin)

The course is very hands-on: you’ll write code from beginning to end. The most rewarding aspect of this course is the completion of the five projects needed to earn a free certificate: a palindrome checker, a roman numeral converter, caesars cipher encrypter, telephone number validator, and a cash register program.

freeCodeCamp has released a new and improved version of this certification: JavaScript Algorithms and Data Structures (Beta); the new version has been praised as much better by some learners on Reddit.

freeCodeCamp is a nonprofit that helps people learn to code for free. They offer 17 courses with free certification! freeCodeCamp’s Youtube Channel has more than 9M subscribers and 1700+ videos on a wide variety of programming and computer science topics. If you’d like to support freeCodeCamp’s mission of providing free education, you can make a donation here.

More freeCodeCamp video courses:

• Data Structures and Algorithms with Visualizations – Full Course (Java) (48 hours)
• Dynamic Programming with Java – Learn to Solve Algorithmic Problems & Coding Challenges (2-3 hours)

For Those Comfortable in Python Programming (Jovian)

Data Structures and Algorithms in Python – Full Course for Beginners introduces you to common data structures (linked lists, stacks, queues, graphs) and algorithms (search, sorting, recursion, dynamic programming) in Python. By the end of this free course, you’ll be prepared to tackle coding interviews, assessment, and a variety of problems, including the well-known knapsack problem.

The course is offered by Jovian on the freeCodeCamp YouTube Channel.

Before taking this course, you’ll need to know basic programming in Python as well as some highschool mathematics.

What you’ll learn:

• Big O notation
• Searching algorithms
• Data structures
• Sorting algorithms
• Divide and conquer
• Dynamic programming
• Graph theory
• Programming mindset and interview preparation
• Algorithm complexity analysis
• Binary Search vs. Linear Search
• Linked lists implementation in Python
• Binary trees: types, traversal, and operations
• Hash tables and Python dictionaries
• Collision handling in hash tables
• Sorting algorithms: bubble, insertion, merge, quick sort
• Time and space complexity analysis
• Dynamic programming, recursion, and memoization
• Graph traversal: breadth-first and depth-first search
• Shortest path algorithms.

You’ll be provided with plenty of Jupyter Notebooks to practice coding along with the lecturer. This course is also available at Data Structures and Algorithms in Python. Jovian also offers many other Python courses related to Data Science, like Data Analysis with Python and Machine Learning with Python.

Best Algorithms Course to Prepare for Technical Interviews (ThePrimeagen)

Welcome to The Last Algorithms Course You’ll Need, a super fun, beginner-friendly data structures and algorithms course with free trial. Is it really the last algorithms course you’ll need? If you want to pass tough interview questions, then yes! ThePrimeagen is enthusiastic and explains concepts clearly.

You’ll need to know some programming for this course. Your subscription to Frontend Masters includes all their frontend and fullstack engineering courses and learning paths.

You’ll learn:

• Basics: Big O time complexity, arrays data structure
• Search: linear search & Kata Setup, binary search algorithm, two crystal balls problem
• Sort: bubble sort, linked list data structures, queue, stack
• Arrays: arrays vs linked list, arraylist, ringbuffer,
• Recursion: path finding
• Quick sort: algorithm and implementing quicksort
• Doubly linked list: prepend, insertAt, and append; remove, get, and removeAt.
• Trees: overview and traversals
• Tree search: breadth-first search, binary tree comparison, depth-first
• Heap, graphs, maps & LRU.

Also check ThePrimeagen’s YouTube channel.

Great Language-Agnostic Course to Prepare for Technical Interviews (Udemy)

If you’re a self-taught developer or anyone anxious of facing a technical interview, this language-agnostic course might be what you’re looking for. The course instructor recommends that you take at least a month to complete it. You’ll mainly learn from watching the course videos, and also by putting theory into practice by coding along with the course and checking your code with the provided solutions.

Master the Coding Interview: Data Structures + Algorithms will help you cut through the technical interview process like a ninja.

Not only will it teach you about the fundamentals of data structures and algorithms and how to ace the coding questions given by leading companies like FAANG, it will also teach you the soft skills needed to increase your chances of getting accepted.

Another thing I like about this course is its focus on community. You’ll have access to their private Discord server where you can get help, chat with other learners and mentors, and most importantly, keep yourself accountable.

What you’ll learn:

• Technical topics
  • Code quality, time-complexity and space-complexity, Big-O notation
  • Data structures: arrays, hash tables, linked lists, stacks & queues, trees and graphs, theory and implementation
  • Algorithms: recursion, sorting algorithms, searching algorithms

• Non-technical topics:
  • Building a portfolio
  • Interview preparation
  • Handling job offers
  • Negotiating raises

• Key skills:
  • Analyzing code efficiency
  • Choosing appropriate data structures
  • Implementing and applying algorithms
  • Optimizing code with dynamic programming

• Career focus:
  • Increasing interview opportunities
  • Boosting confidence in coding interviews
  • Professional development.

The course has an extra section on how to contribute to open source. Andrei is the instructor of some of the highest rated programming and technical courses online and is the founder of ZTM academy. He is also a self-taught programmer, and knows the struggles of being one.

How We Made Our Picks and Tested Them

I built this guide following the now tried-and-tested methodology I used in previous guides (you can find them all here). It involves a three-step process:

First, let me introduce myself. As part of the Class Central team, I (@elham) built this guide in collaboration with my friend and colleague @manoel.

We began with a purely data-driven process by leveraging Class Central’s database of over 200K courses to make a preliminary selection of DSA courses. We took a look at things like ratings, reviews, and course bookmarks to bring you some of the most popular DSA courses.

But we didn’t stop there. Ratings and reviews rarely tell the whole story. So the next step was to bring our personal knowledge of online education into the mix.

Second, we used our experience as online learners to evaluate each preliminary pick.

Both of us come from computer science backgrounds and are prolific online learners, having completed about 45 open online courses between us. Additionally, Manoel has an online bachelor’s in computer science, while I am currently completing my foundation in computer science. So we know our way around algorithms and data structures!

By carefully analyzing each course and bouncing ideas off each other, we’ve made iterative improvements to the guide until we were both satisfied.

Third, during our research, we found courses that we felt were well-made but weren’t well-known. Had we adopted a purely data-centric approach, we would be forced to leave those courses out of the guide just because they had fewer enrollments.

To avoid this, we have decided instead to take a more holistic approach. We spiced up the guide by including a wide range of courses on data structure and algorithms that will hopefully cater to different reader’s preferences.

After going through this process — combining Class Central data, our experience as lifelong learners, and a lot of editing — we arrived at our final list.

Pat revised the research and the latest version of this article.