Find online courses made by experts from around the world.
Take your courses with you and learn anywhere, anytime.
Learn and practice real-world skills and achieve your goals.
This course provides a comprehensive overview of the concepts of algorithm analysis and development. I attempted to make the course as straightforward as possible, to the point where no previous experience in algorithm analysis or formal computer science education is required. The videos review popular algorithms such as merge sort, radix sort, Huffman coding, and many more, along with some of the data structures that are utilized in combination with these algorithms, such as queues and stacks. I also review a number of graph algorithms and give introductions to additional advanced algorithm analysis concepts.
I developed this course while I was taking a graduate level Analysis of Algorithms course from Texas Tech University, and these are all the main topics that we discussed.
Not for you? No problem.
30 day money back guarantee.
Forever yours.
Lifetime access.
Learn on the go.
Desktop, iOS and Android.
Get rewarded.
Certificate of completion.
Section 1: Introduction to Algorithms | |||
---|---|---|---|
Lecture 1 | 03:54 | ||
This course provides a comprehensive overview of the concepts of algorithm analysis and development. I attempted to make the course as straightforward as possible, to the point where no previous experience in algorithm analysis or formal computer science education is required. The videos review popular algorithms such as merge sort, radix sort, Huffman coding, and many more, along with some of the data structures that are utilized in combination with these algorithms, such as queues and stacks. I also review a number of graph algorithms and give introductions to additional advanced algorithm analysis concepts. |
|||
Lecture 2 | 10:49 | ||
This video walks through the growth of functions, especially how they are related to algorithm development and analysis. Reviewed in the video are the concepts that make up the Big O complexity chart. |
|||
Section 2: Sorting Algorithms | |||
Lecture 3 | 12:03 | ||
This video gives an easy to follow description for how the insertion sort algorithm functions. Despite its poor performance for the majority of data sets, insertion sort is a great starting point for learning about algorithms and can be utilized if a data set is not too large or is already close to being sorted. |
|||
Lecture 4 | 09:18 | ||
This video walks through a visualization for the counting sort algorithm. Counting sort is a unique algorithm that is not typically used by itself to sort data, instead it is usually utilized as a subroutine for algorithms such as Radix sort. This algorithm is not the most intuitive for many students, so it may be helpful to watch the visualization several times until you understand how the values get sorted. |
|||
Lecture 5 | 05:44 | ||
The Radix sort algorithm is a power algorithm for sorting fixed integer sets and strings that all have the same number of characters. The algorithm iterates through each column of the data set and sorts it before moving onto the next column. You can see an implementation of the Python code here: https://gist.github.com/jordanhudgens/9442741 |
|||
Lecture 6 | 10:54 | ||
This video explains how the popular merge sort algorithm works. Some of the properties of merge sort are: Time complexity - O(n lg n), it's recursive, it's a stable sorting algorithm, and it utilizes the divide and conquer technique. |
|||
Section 3: Abstract Data Structures | |||
Lecture 7 | 05:02 | ||
Stacks are utilized in a number of different languages and algorithms, and it's important to know how they are practically implemented. In this tutorial I walk through some of the basic properties of stacks, specifically how they are structured and how to push/pop elements on and off of a stack. |
|||
Lecture 8 | 06:37 | ||
In this video I walk through an introduction to the queue, which is an abstract data structure. I show how to use the enqueue and dequeue methods to add and remove elements, and show how to implement the data structure into linked lists and arrays. |
|||
Section 4: Binary Search Trees | |||
Lecture 9 | 07:46 | ||
In this video I walk through the components of a binary search tree, from the root node all the way through the leaf. I also describe how to quickly find the minimum and maximum values of the tree. |
|||
Lecture 10 | 11:46 | ||
This tutorial gives a step by step explanation on how to search through a binary search tree, it also compares binary search trees with linear search along with showing the effects of a poorly balanced tree. |
|||
Lecture 11 | 05:16 | ||
In this algorithm tutorial, I walk through how to construct a binary search tree given an unordered array, and then how to find elements inside of the tree. |
|||
Lecture 12 | 04:35 | ||
In this video I walk through how to delete nodes from a binary search tree. Specifically I explain how to delete: the root node, a node with one child, a node with two children, and a leaf node. |
|||
Lecture 13 | 03:02 | ||
In this video I walk through how to traverse a binary search tree utilizing the preorder method. I attempted to make it as simple as possible, by giving each node a number in the order that I traverse the data structure. |
|||
Lecture 14 | 03:10 | ||
In this video I walk through how to traverse a binary search tree utilizing the postorder method. I attempted to make it as simple as possible, by giving each node a number in the order that I traverse the data structure. |
|||
Section 5: Red Black Trees | |||
Lecture 15 | 09:21 | ||
In this video I walk through the properties of Red Black Trees. The properties of the trees are as follows: Every node is either red or black, ever leaf is black, the root node is always black, each of the paths from the root to the leaves have the same number of black nodes, no path from the root to the leaf has two consecutive red nodes, nodes are inserted in the same way, initially, as a binary search tree, and the tree is re-balanced by re-coloring. |
|||
Lecture 16 | 04:25 | ||
In this video I review how to traverse and find elements in a Red Black tree. This process is the same as with a binary search tree, however it has the added benefit of always resulting in a O(lg n) time complexity due to the tree being balanced. |
|||
Lecture 17 | 05:08 | ||
This video explains how to perform a rotate action on a red black tree. Red black trees are data structures that have the purpose of maintaining balance, thus resulting in more consistent performance. |
|||
Lecture 18 | 05:25 | ||
In this video I walk through the process of deleting a node from a red black tree, the key to remember at this stage is that after deleting the node the tree needs to go through a re-balancing/coloring process to ensure all of the properties are once again satisfied. |
|||
Section 6: Graph Algorithms | |||
Lecture 19 | 05:54 | ||
This video explains the differences between Hamiltonian and Euler paths. The keys to remember are that Hamiltonian Paths require every node in a graph to be visited a single time, whereas Euler Paths require that every edge be visited once. The difference seems subtle, however the resulting algorithms show that finding a Hamiltonian Cycle is a NP complete problem, and finding a Euler Path is actually quite simple. |
|||
Lecture 20 | 07:56 | ||
In this video I walk through Prim's Algorithm, this process establishes the ability to find a minimum spanning tree in a graph by utilizing a greedy approach. |
|||
Lecture 21 | 06:42 | ||
In this tutorial I walk through how the breadth first search tutorial. The key to remember in this algorithm is that you iterate through each 'level' to find the element you are looking for. This is a great algorithm for artificial intelligence. |
|||
Lecture 22 | 04:08 | ||
In this video I walk through the depth first search algorithm, there are some notable differences between depth first search and breadth first search and I highly suggest you review both algorithm videos to ensure that you are familiar with the processes. The depth first search has some commonalities with postorder traversal through a binary search tree. |
|||
Section 7: Advanced Algorithms | |||
Lecture 23 | 09:25 | ||
This video walks through the basic concepts of Huffman Coding. Huffman coding is a great algorithm for data compression and works by limiting the number of bits that are required by a character, this type of algorithm is very useful in such fields as bio-infomatics, that have a small number of letters but a large amount of data that needs to be compressed. |
|||
Lecture 24 | 05:10 | ||
In this video I give a high level explanation of how greedy algorithms work. Essentially greedy algorithms select the highest values first, and then move down to lower values. The key to knowing if a greedy algorithm is going to give an optimal solution is highly dependent on the data values. |
|||
Lecture 25 | 03:48 | ||
In this video I show how a greedy algorithm can and cannot be the optimal solution for a shortest path mapping problem. As with the majority of algorithm problems, it is key to understand the data that you will be dealing with, or else you could end up with a very poor performing solution. |
|||
Lecture 26 | 10:21 | ||
In this video I show how a greedy algorithm can and cannot be the optimal solution for a shortest path mapping problem. As with the majority of algorithm problems, it is key to understand the data that you will be dealing with, or else you could end up with a very poor performing solution. |
Jordan Hudgens is the CTO and Founder of DevCamp where he leads instruction and curriculum development for all of the DevCamp and Bottega code schools around the US.
As a developer for over the past decade, Jordan has traveled the world building applications and training individuals on a wide variety of topics, including: Ruby development, big data analysis, and software engineering.
Jordan focuses on project driven education, as opposed to theory based development. This style of teaching is conducive to learning how to build real world products that adhere to industry best practices.
Additionally Jordan has published multiple books on programming and computer science, along with developing training curriculum for Learn.co, devCamp, and AppDev on the topics of Ruby on Rails, Java, AngularJS, NoSQL, API development, and algorithms.