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.