Comprehensive Algorithms
3.5 (38 ratings)
2,577 students enrolled
Wishlisted Wishlist

# Comprehensive Algorithms

This course provides a comprehensive overview of the concepts of algorithm analysis and development.
3.5 (38 ratings)
2,577 students enrolled
Created by Jordan Hudgens
Last updated 5/2014
English
Current price: \$10 Original price: \$20 Discount: 50% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
• 3 hours on-demand video
• Access on mobile and TV
• Certificate of Completion
What Will I Learn?
• By the end of this course you will have a thorough understanding of some of the most popular algorithms and data structures
View Curriculum
Requirements
• No previous experience is required
Description

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.

Who is the target audience?
• Computer science students
• Programmers
• Mathematicians
Students Who Viewed This Course Also Viewed
Curriculum For This Course
26 Lectures
02:57:39
+
Introduction to Algorithms
2 Lectures 14:43

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.

Preview 03:54

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.

Preview 10:49
+
Sorting Algorithms
4 Lectures 37:59

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.

Insertion Sort
12:03

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.

Counting Sort
09:18

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

05:44

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.

Merge Sort
10:54
+
Abstract Data Structures
2 Lectures 11:39

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.

Stacks
05:02

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.

Queues
06:37
+
Binary Search Trees
6 Lectures 35:35

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.

Binary Search Tree Introduction
07: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.

Searching Through a Binary Search Tree
11:46

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.

How to Construct a Binary Search Tree
05:16

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.

How to Delete a Node from a Binary Search Tree
04:35

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.

Preorder Binary Tree Traversal
03:02

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.

Postorder Binary Tree Traversal
03:10
+
Red Black Trees
4 Lectures 24:19

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.

Properties of Red Black Trees
09:21

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.

Red Black Tree Traversal
04:25

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.

How to Rotate a Red Black Tree Data Structure
05:08

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.

How to Delete a Node from a Red Black Tree
05:25
+
Graph Algorithms
4 Lectures 24:40

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.

Hamiltonian vs Euler Paths
05:54

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.

Prim's Algorithm
07:56

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.

06:42

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.

Depth First Search
04:08
+
4 Lectures 28:44

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.

Huffman Codes
09:25

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.

Introduction to Greedy Algorithms
05:10

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.

Greedy Algorithm for Shortest Path Problem
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.

How to Develop a Good Hash Function
10:21