**Learning Data Structures and Algorithms**

English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 8 Hours | 0.98 GB

eLearning | Skill level: Beginner | by Rod Stephens

Implementation and Analysis for Increased Software Performance

In this Learning Data Structures and Algorithms training course, expert author Rod Stephens will teach you how to analyze and implement common algorithms used. This course is designed for the absolute beginner, meaning no previous programming experience is required.

You will start by learning about the complexity theory, then jump into learning about numerical algorithms, including randomizing arrays, prime factorization, and numerical integration. From there, Rod will teach you about linked lists, such as singly linked lists, sorted, and doubly linked lists. This video tutorial also covers arrays, stacks and queues, and sorting. You will also learn about searching, hash tables, recursion, and backtracking algorithms. Finally, you will cover trees, balanced trees, decision trees, and network algorithms.

Once you have completed this computer based training course, you will be fully capable of analyzing and implementing algorithms, as well as be able to select the best algorithm for various situations. Working files are included, allowing you to follow along with the author throughout the lessons.

Table of Contents

**1. Introduction**

Introduction And Course Overview

About The Author

How To Access Your Working Files

**2. Complexity Theory**

Complexity Theory

Big O Notation

Typical Runtime Functions

Comparing Runtime Functions

P And NP

**3. Numerical Algorithms**

Random Numbers

Linear Congruential Generators

Randomizing Arrays – Part 1

Randomizing Arrays – Part 2

GCD

LCM

Prime Factorization – Part 1

Prime Factorization – Part 2

Finding Primes

Testing Primality

Numerical Integration

**4. Linked Lists**

Singly Linked Lists – Part 1

Singly Linked Lists – Part 2

Sorted Linked Lists

Sorting With Linked Lists

Doubly Linked Lists

**5. Arrays**

One-Dimensional Arrays

Triangular Arrays – Part 1

Triangular Arrays – Part 2

Sparse Arrays – Part 1

Sparse Arrays – Part 2

**6. Stacks And Queues**

Stacks

Stack Algorithms

Double Stacks

Queues

**7. Sorting**

Sorting Algorithms

Insertionsort

Selectionsort

Quicksort – Part 1

Quicksort – Part 2

Heapsort – Part 1

Heapsort – Part 2

Heapsort – Part 3

Mergesort – Part 1

Mergesort – Part 2

Bubblesort – Part 1

Bubblesort – Part 2

Countingsort – Part 1

Countingsort – Part 2

Sorting Summary

**8. Searching**

Linear Search

Binary Search

Interpolation Search

**9. Hash Tables**

Hash Tables

Chaining

Open Addressing – Basics

Open Addressing – Linear Probing

Open Addressing – Quadratic Probing

Open Addressing – Double Hashing

**10. Recursion**

Recursion Basics

Fibonacci Numbers

Tower Of Hanoi

Koch Curves

Hilbert Curves

Gaskets

Removing Tail Recursion

Removing Recursion With Stacks

Fixing Fibonacci

Selections

Permutations

**11. Backtracking Algorithms**

Backtracking

The Eight Queens Problem – Part 1

The Eight Queens Problem – Part 2

The Eight Queens Problem – Part 3

The Knights Tour

**12. Trees**

Tree Terms

Binary Tree Properties

Traversals – Preorder

Traversals – Postorder

Traversals – Inorder

Traversals – Breadth-First

Building Sorted Trees

Editing Sorted Trees

**13. Balanced Trees**

Why Do You Need Balanced Trees?

B-Trees – B-Tree Basics

B-Trees – Adding Items

B-Trees – Removing Items

AVL Tress – Part 1

AVL Tress – Part 2

**14. Decision Trees**

Definition

Exhaustive Search

Branch And Bound

Heuristics

**15. Network Algorithms**

Network Terminology

Network Classes

Depth-First Traversal

Breadth-First Traversal

Spanning Trees – Part 1

Spanning Trees – Part 2

Shortest Paths – Part 1

Shortest Paths – Part 2

All Pairs Shortest Path – Part 1

All Pairs Shortest Path – Part 2

**16. Wrap-Up**

Wrap-U

Resolve the captcha to access the links!