# Data Structures and Algorithms: Deep Dive Using Java

Data Structures and Algorithms: Deep Dive Using Java
English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 16 Hours | 1.76 GB

Learn about Arrays, Linked Lists, Trees, Hashtables, Stacks, Queues, Heaps, Sort algorithms and Search algorithms

This is a hands-on course! If you want to try understand things at a deep level, and work on implementations, rather than theory, then again, this is the course for you.

Topics covered:

• Arrays
• Trees
• Hashtables
• Stacks
• Queues
• Heaps
• Sort algorithms
• Search algorithms

The course also spends more time than most other courses of its kind looking at what’s available in the JDK. Students wanting to understand how things work “under the hood” will benefit enormously from this course.

The reality is, the more you learn about data structures and algorithms, the better a programmer you become.

After completing this course, you will have a solid understanding of data structures and algorithms (both the theory, and the implementation).

What Will I Learn?

• Learn the strengths and weaknesses of a variety of data structures, so you can choose the best data structure for your data and applications
• Code an implementation of each data structure, so you understand how they work under the covers
• Learn many of the algorithms commonly used to sort data, so your applications will perform efficiently when sorting large datasets
• Learn what’s available in the JDK for storing and sorting data, so you won’t waste time reinventing the wheel

Introduction
1 Introduction to the Course
2 JDK8 for Windows
3 JDK8 for MAC
4 JDK8 for Linux
5 IntelliJ for Windows
6 IntelliJ for MAC
7 IntelliJ for Linux
8 Introduction to Data Structures
9 Introduction to Algorithms

Arrays and Big-O Notation
10 Introduction to Arrays
11 Big-O Notation
12 A Quick Review of Arrays in Java
13 Arrays in Memory
14 Big-O Values for Array Operations

Sort Algorithms
15 Introduction to Sort Algorithms
16 Bubble Sort (Theory)
17 Bubble Sort (Implementation)
18 Stable vs. Unstable Sort Algorithms
19 Selection Sort (Theory)
20 Selection Sort (Implementation)
21 Insertion Sort (Theory)
22 Insertion Sort (Implementation)
23 Shell Sort (Theory)
24 Shell Sort (Implementation)
25 Recursion
26 Merge Sort (Theory)
27 Merge Sort (Implementation)
28 Quick Sort (Theory)
29 Quick Sort (Implementation)
30 Counting Sort (Theory)
31 Counting Sort (Implementation)
33 Stable Counting Sort (Theory)
35 Sorting Arrays Using the JDK
36 Sort Algorithms Challenge 1
37 Sort Algorithms Challenge 1 Solution
38 Sort Algorithms Challenge 2
39 Sort Algorithms Challenge 2 Solution
40 Sort Algorithms Challenge 3
41 Sort Algorithms Challenge 3 Solution

Lists
42 Introduction to Lists
43 Abstract Data Types
44 Array Lists
45 Vectors
52 Linked Lists Challenge 1 Solution
54 Linked Lists Challenge 2 Solution

Stacks
55 Introduction to Stacks
56 Stacks (Theory)
57 Stacks Implementation (Array)
59 Stacks Challenge
60 Stacks Challenge Solution

Queues
61 Introduction to Queues
62 Queues (Theory)
63 Queues (Array Implementation)
64 Circular Queue Implementation (Part One)
65 Circular Queue Implementation (Part Two)
66 Queues and the JDK
67 Queues Challenge
68 Queues Challenge Solution

Hashtables
69 Introduction to Hashtables
70 Hashtables (Theory)
71 Hashtables (Array Implementation)
72 Linear Probing
73 Linear Probing – Removing Items
74 Linear Probing – Rehashing
75 Chaining
76 Hashtables and the JDK
77 Bucket Sort (Theory)
78 Bucket Sort (Implementation)
79 Hashtables Challenge 1
80 Hashtables Challenge 1 Solution
81 Hashtables Challenge 2
82 Hashtables Challenge 2 Solution

Search Algorithms
83 Introduction to Search Algorithms
84 Linear Search Algorithm
85 Binary Search Algorithm
86 Binary Search (Implementation)

Trees
87 Introduction to Trees
88 Trees (Theory)
89 Binary Search Trees (Theory)
90 Binary Search Trees (Insertion)
91 Binary Search Trees (Traversal)
92 Binary Search Trees (Get Min Max)
93 Binary Search Trees (Delete Cases 1 and 2)
94 Binary Search Trees (Implement Cases 1 and 2)
95 Binary Search Trees (Delete Case 3)
96 Binary Seach Trees (Implement Case 3)
97 Trees and the JDK
98 Binary Search Trees Challenge 1
99 Binary Search Trees Challenge 1 Solution
100 Binary Search Trees Challenge 2

Heaps
101 Introduction to Heaps
102 Heaps (Theory)
103 Storing Heaps as Arrays
104 Heaps (Insert)
105 Heaps (Delete Theory)
106 Heaps (Delete)
107 Heaps (Peek)
108 Priority Queues
109 Heapsort (Theory)
110 Heapsort (Implementation)

Course Wrap-Up
111 Sets
112 Course Wrap-Up

Bonus Material