Algorithms and Data Structures - Part 1

A look at the core data structures and algorithms used in day-to-day applications.
Course info
Rating
(1089)
Level
Beginner
Updated
Aug 15, 2011
Duration
3h 13m
Table of contents
Description
Course info
Rating
(1089)
Level
Beginner
Updated
Aug 15, 2011
Duration
3h 13m
Description

In this course we will look at the core data structures and algorithms used in everyday applications. We will discuss the trade-offs involved with choosing each data structure, along with traversal, retrieval, and update algorithms. This is part 1 of a two-part series of courses covering algorithms and data structures. In this part we cover linked lists, stacks, queues, binary trees, and hash tables.

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 2
Intermediate
2h 30m
11 Jun 2012
More courses by Robert Horvick
Section Introduction Transcripts
Section Introduction Transcripts

Algorithms and Data Structures 1: Linked List
Welcome to the Pluralsight Algorithms and Data Structures course. My name is Robert Horvick, and throughout this course I'll be introducing you to some of the most common data structures used in computer programming. We'll also look at many of the algorithms that are associated with these structures. This first module will focus on the Linked List Data Structure, as well as introduce some concepts that will be referred to throughout the course. I'll start by introducing the Node. This is the basic building block of many of the Data Structures we'll see in this course. Next, we'll see how nodes can be linked together to form chains of nodes, and then we'll see how these chains form the basis of the Linked List Data Structure. We'll also look at the Linked List and see how there are several types of operations that can be performed. I'll introduce an extension of the Linked List, known as the Doubly Linked List, and finally, we'll look at how the Linked List Data Structure is implemented in. NET and C++.

Algorithms and Data Structures: Stack
Hello, and welcome to the Algorithms and Data Structures course. In this module, I'll be introducing the Stack Data Structure. We'll begin by building on concepts introduced in the Link List module. So, if you aren't already comfortable with Linked Lists, I would encourage you to watch that module first. Through this module, we're going to be learning about several concepts and seeing some examples. We're going to start by learning what Last In First Out means, and how it really defines what a Stack is. Next, we'll implement a Stack using a Linked List as the storage medium for the data, and then we'll implement a Stack using an Array for data storage. After that, we'll see an example of a Postfix Calculator implemented using a Stack, and we'll look at a simple example of how a Stack can make it easier to implement "Undo" operations in your application. Finally, we'll take a brief look at the implementations of Stacks in both the. NET framework and within C++.

Algorithms and Data Structures 1: Queue
Hello. My name is Robert Horvick, and welcome to the Algorithms and Data Structures course. In this module, we're going to be learning about the Queue Data Structure. A Queue is a First In, First Out collection. This is in contrast to the Stack collection seen in the previous module that was a First In, Last Out collection. We'll learn more about what this means in just a few moments. We'll also see how items are added and removed from the Queue using the Enqueue and Dequeue operations. We'll look at two implementations of the Queue structure, one using a Linked List and one using an Array, and we'll look at a very useful specialization of the Queue, the Priority Queue. Finally, we'll look at some of the implementations that are available in the. NET framework and C++, and along the way we'll look at quite a bit of code, and we'll see some live examples of Queues in action.

Algorithms and Data Structures: Binary Trees
Welcome to the Pluralsight Algorithms and Data Structures course. My name is Robert Horvick, and in this module we're going to be learning about Binary Trees. In previous modules, we've looked at structures that link data into chains. In this module we're going to learn about structures that order data into a Tree. We'll learn about how this Tree can be used to create a Binary Tree, or more specifically, a Binary Search Tree. We'll see how to Add and Remove items from the Tree; we'll search for data within the Tree; and we'll learn how to traverse or enumerate the data in the Tree using three different node ordering algorithms.

Algorithms and Data Structures: Hash Tables
Hello, and welcome to the Pluralsight Algorithms and Data Structures course. My name is Robert Horvick, and in this module, we're going to be looking at the Hash Table Data Structure. We'll start by taking a very high-level look at what Hash Tables are, and how they fit into the broad category of structures known as Associative Arrays. Next, we'll spend some time looking at Hashing. What we'll see is that while Hashing may appear simple, it's actually quite difficult to get right. Once we have a solid understanding of those concepts, we'll see how to Add items to a Hash Table, and then how to Remove them. Then we'll see how to Search for items in a Hash Table, and finally, how to Enumerate the items in a Hash Table.