Comprehensive Algorithms

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.

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.

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

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.

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.

This guide walks through how to implement a Stack data structure using the Python programming language.

This data structure guide walks through a practical example use case for the Stack structure. In the lesson you'll learn how to reverse a string, which illustrates the behavior of the Stack data structure.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

This supplement is a good example showing how a factorial can work in the Ruby programming language.