JomaClass Presents

# Data Structures & Algorithms

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

8:19

The List is a collection of elements that are sequenced. We'll try to implement it using bare C-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?

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?

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?

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.

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.

11:23

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.

Recorded
TBD
Run time
TBD
Difficulty
Intermediate

#### Prerequisites:

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

### Enroll Today

JomaClass is \$8/month (billed annually)

### Practice your theory 50+ with coding problems

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.

### Get free JomaClass videos

Enter your email and we’ll send you Data Structures & Algorithms videos and some samples of our favorite courses.

## Recommended for:

#### Coding Interviews

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.

#### Computer Science Students

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.

#### Competitive Programmers

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.

#### What you'll learn in this class:

• 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

#### Included in this class:

• 10 high-quality lecture videos with intuitive animations
• 50+ videos on coding problems and their solutions

## What's in every JomaClass subscription?

• All 80+ high quality videos from other classes
• New videos added every week

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.

A typical course will have around 20 video lessons.

Close

50% Complete

### Unlock All Videos and Courses

Create your account to get started.