Browse Lessons

1. Introduction to Data Structures and Algorithms

12:03

What exactly is an algorithm? In this lesson you'll learn that you use algorithms every day in your daily lives. We also go through what the difference between an Abstract Data Type (ADT) and a data structure is.

2. Time Complexity and Asymptotic Analysis

10:20

We learn about the big O notation and the different time complexities and why they matter more than just the time it takes to execute a program.

3. Understanding the Memory Model

6:12

We quickly go over what pointers are and how addresses work in memory. We also talk about bits and bytes and how that becomes different data types

4. List ADT: Array Implementation

8:19

The List is a collection of elements that are sequenced. We'll try to implement it using bare C-arrays.

5. List ADT: Dynamic Arrays

16:32

To implement the List, we need to dynamically allocate more memory for our array so we can put more elements in our list. How do we do that in the most efficient way?

6. List ADT: Linked List Implementation

10:16

Let's try using another data structure to implement the list. What are the pros and cons of using a LinkedList instead of an array?

7. List ADT: Linked List Implementation 2

6:43

We continue coding the implementation of the List ADT using LinkedLists. How do we optimize this implementation to reduce the time complexity of our operations?

8. Stack ADT

12:45

The stack is a very common ADT to use especially when implementing recursive algorithms iteratively or depth first search algorithms. We will teach you different ways of implementing a stack and the trade-offs between them.

9. Queue ADT

7:54

The queue is like the opposite of the stack. Instead of being first in last out, it's a first in first out collection of elements. It's very useful for algorithms like Breadth first search on graphs.

10. Double-Ended Queue

4:32

What is we can enqueue and dequeue from both the front and the back? What would we need to do in order to be able to do those operations in constant time? The key is node augmentation. By adding a few more fields in your Node structure, you can do so much more. This will be important for implementing Trees and Graphs.

11. Tree, Binary Tree, BST

4:39

Trees are one of the most important data structures in computer science because they allow you to store data in a hierarchical structure. This allows you to retrieve items more quickly than just linearly scanning through a list or array. We’re going to learn about the difference between Tree, Binary Tree, and Binary Search Tree.

12. Binary Search Tree: Implementation

9:01

Binary Search Trees allow us to search for values in a collection in O(log(n)) time which is very efficient. We are going to learn how to implement a BST using nodes.

13. Binary Search

6:05

Now that you learned about binary search trees, you’ll learn that you can actually perform a binary search on an ordinary array. We go through a guessing game and compare that with a binary search which will show you how common you actually perform binary searches in your day to day life.

14. Hash Tables and Dictionary ADT

9:53

Hash tables are very useful for implementing dictionaries. Dictionary allows you to get a value based on a key. With hash tables, you can retrieve a value given a key in O(1) time. We’ll teach you how to implement a hash table using arrays and linked lists.

15. Heap and Priority Queue ADT

TBD

Priority Queues are like queues but instead of dequeuing the first element you inserted, you dequeue the element with the highest priority. How would you implement that? You will learn what a heap is and how that data structure is perfect for implementing a priority queue.

16. Sorting Algorithms: Selection Sort & Quicksort

10:00

There are multiple sorting algorithms and they both have their pros and cons. Selection sort is one of the most simple sorting algorithms but it has high time complexity. You will also learn to implement Quicksort which is used in many libraries.

17. Sorting Algorithms: Merge Sort & Heapsort

TBD

In this lesson, you’ll learn how to implement merge sort and heapsort, which are both O(nlogn) algorithms. We will then compare all the sorting algorithms we’ve learned and look at their advances and disadvantages.

18. Graph

4:43

You will learn what graphs are and how they are useful in computer science. You will learn about different types of graphs like undirected vs directed, weighted vs unweighted, and how graphs are related to trees.

19. Graph Representation: Edge List, Adjacency Matrix, and Adjacency Lists

11:23

There are many ways of representing a graph in your programs. Each of them has its own advantages and disadvantages. We’ll be learning about the Edge list, Adjacency Matrix, and Adjacency lists.

20. Graph: Breadth-first Search

5:59

There are many ways of exploring a graph. The two main ways are the breadth-first search (BFS) and depth-first search (DFS). In this lesson, we’ll be learning how to write a BFS function.

21. Graph: Depth-first Search

7:09

The second way of exploring a graph is to perform a depth-first search (DFS). We’ll be learning how to write a depth-first search function using recursion.

Data Structures and Algorithms is one of the most sought after topics in computer science. A deep understanding of DS&A separates the top programmers from others. This is probably why most coding interviews will ask you to implement various algorithms that have to leverage these data structures. We teach this course with the best visualizations and animations so you can truly understand the concepts and develop a strong intuition for it.

- Know what a pointer and memory addresses are
- Proficient in at least one programming language
- Have a good understanding of Programming Fundamentals

**JomaClass is $8/month (billed annually)**

We have over 50 videos on different coding problems to help you reinforce your learning. Not only should you be familiar with the theory, but you also have to be able to apply them.

Most technical interviews require you to solve brain teaser problems that are related to data structures and algorithms. They expect you to master them and be able to analyze the time and space complexity of your implementation.

As a CS student, you'll eventually take a Data Structure or Algorithms course. With this course, you'll be able to complement your learning and maybe develop a deeper understanding of it with our intuitive animations.

If you want to become a competitive programmer, then you should learn the basics. Data structures and algorithms will be the first techniques you'll learn before going into more advanced algorithms and techniques in competitive programming.

- How to analyze programs in terms of time and space complexity with big O notations.
- Implement Abstract Data Types with various data structures and their pros and cons
- Most common algorithms to sort, search, and store elements

- 10 high-quality lecture videos with intuitive animations
- 50+ videos on coding problems and their solutions
- Access to your instructor to answer all your questions about the course content

- Access to Joma for mentorship through private forum
- All 80+ high quality videos from other classes
- New videos added every week

What is JomaClass?

Think of it like a Patreon subscription where you get access to all my educational videos on programming, computer science, and data science. I make sure to teach the right things in the right order since a lot of students tend to give up or they don't build the right foundations.

I post multiple videos weekly and I'm constantly working on a new course. In addition, you have full access to a private group where you can interact with me and other students in the community.

How much does the JomaClass subscription cost?

$8/month paid yearly.

How many lessons are in the course?

A typical course will have around 20 video lessons.

Close
### Unlock All Videos and Courses

50% Complete

Create your account to get started.