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.
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.
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
The List is a collection of elements that are sequenced. We'll try to implement it using bare C-arrays.
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?
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?
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?
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Enter your email and we’ll send you Data Structures & Algorithms videos and some samples of our favorite courses.
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.
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.
$8/month paid yearly.
A typical course will have around 20 video lessons.