Description
Course info
Rating
(442)
Level
Intermediate
Updated
Jun 11, 2012
Duration
2h 30m
Description

In this course we will look at some advanced data structures and algorithms used in everyday applications. We will discuss the trade-offs involved with choosing each data structure and algorithm and see some real world usage examples. This is part 2 of a two-part series of courses covering algorithms and data structures. In this part we cover data sorting, string searching, sets, AVL trees and concurrency issues.

About the author
About the author

Robert spent nearly 10 years at Microsoft creating software that made it easier for everyone else to write software. Most recently Robert worked on Team Foundation Server on the Administration and Version Control teams. Currently Robert can be found working in the utilities sector on Smart Grid technologies.

More from the author
Data Visualizations Using Tableau Public
Intermediate
1h 47m
10 Sep 2013
Twilio Service Basics
Intermediate
1h 7m
6 Mar 2013
Algorithms and Data Structures - Part 1
Beginner
3h 13m
15 Aug 2011
More courses by Robert Horvick
Section Introduction Transcripts
Section Introduction Transcripts

Sorting Algorithms
Hello. Welcome to the Pluralsight Algorithms and Data Structures 2 course. I'm Robert Horvick. And in this module, we'll be looking at several different algorithms for sorting data. First, we're going to have a quick conceptual overview of what data sorting is, and then we'll talk about how to measure the performance of various algorithms. This will help give us a common framework to compare the various algorithms and to learn when to pick one over another. Next, we're going to look at the five sorting algorithms that are being covered in this course. We'll start with the most basic sorting algorithm, the bubble sort, and we'll end with one of the most commonly used algorithms, the quick sort. Finally, we'll look in the sample application that will help visualize and compare the performance of each of the algorithms presented in this module.

Set Collection and Algorithms
Welcome to the Algorithms and Data Structures 2 course. My name is Robert Horvick, and in this module, we'll be learning about the set data type and some commonly associated algorithms. We'll start by first learning about what a set is. Next, we'll see how that might be translated into a set class. This class will look and feel like a typical dot net framework collection. After that, we'll look at the four algorithms commonly associated with sets. These are the union, intersection, set difference and symmetric difference algorithms. We'll look at how a set class can be used in a sample application. And we'll briefly look at set classes and algorithms in the dot net framework and in the C plus plus standard template library.

AVL Tree
Hello. My name is Robert Horvick and welcome to the Algorithms and Data Structures 2 Course. In this module, we will be learning about the AVL tree data structure. We will start this course by reviewing the binary tree data structure and comparing at a high level the differences between a balanced and an unbalanced binary tree. Next, we will start looking at the base implementation of the AVL tree. We will see how it is very similar to the binary tree structure and we'll learn about how it differs. With the general tree structure understood, we will move on to learning how tree balancing works by reviewing the four balancing algorithms the AVL tree employs. Finally, we will look at an example where we will visualize both binary and AVL trees to see how they differ structurally when given identical data. ( Pause )

String Searching Algorithms
Hello, and welcome to the Algorithms and Data Structures II Course. My name is Robert Horvick and in this module, we will be learning about string searching. Before diving into the string searching algorithms, we are first going to look at the string searching API we'll be using. This API will provide a common framework for implementing the search algorithms and for creating a sample application later in the module. The first algorithm we are going to look at is the naive search algorithms. We will start by taking some time to understand how the algorithm works and then look at some code and finally, we'll discuss the performance considerations of using this algorithm. Next, we will look at the Boyer-Moore-Horspool Algorithm. This is a simplified version of the Boyer-Moore Algorithm. Like the naive algorithm, we'll first learn how the algorithm works and then we'll look at some code and finally, we'll discuss the performance considerations. Last, we'll look at a demo application that uses both algorithms to perform string search and replace operations. This will allow us not only to see the algorithms in action but also compare their performance.

Collection Concurrency
Horvick: Hello. Welcome to the algorithms and data structures collection concurrency module. In this module, we're going to be learning about how concurrency issues affect collection usage, and we will see several ways to address concurrency issues. We will start this module by briefly discussing what concurrency is, and then we will look at a specific issue where a q collection can return the same item twice due to a race condition. Next, we will look at several different solutions to collection concurrency. We will look at caller synchronization, synchronization using monitor locks, and synchronization using reader/writer locks. Finally we will look at what. Net offers in terms of concurrent collections.