Data Structures and Algorithms: Deep Dive Using Java

About Course

Enhance your programming skills with a deep dive into **Data Structures and Algorithms using Java**. This comprehensive course, completely **free** and available on **Theetay**, will equip you with the knowledge and practical skills to excel in software development.

Offered by **Udemy**, this course goes beyond theoretical concepts to provide a hands-on understanding of data structures and algorithms, including:

Arrays
Linked Lists
Trees
Hashtables
Stacks
Queues
Heaps
Sort algorithms
Search algorithms

Taught by experienced software developer **Sarah Ettritch**, this course emphasizes implementation, giving you a solid foundation to build your own programs. You’ll gain a thorough understanding of the Java Development Kit (JDK) and learn how to apply these concepts to real-world projects.

By mastering data structures and algorithms, you’ll become a more efficient and effective programmer, equipped to solve complex problems with elegance and efficiency. This course is ideal for anyone seeking to advance their programming career and gain in-demand skills.

Start your journey to becoming a more proficient Java developer today! **Sign up for free** and unlock your potential.

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

Course Content

Introduction

A Message from the Professor
Introduction From Tim Buchalka

01:56
Introduction to the Course

03:42
JDK8 for Windows

05:15
JDK8 for MAC

02:44
JDK8 for Linux

04:20
IntelliJ for Windows

09:54
IntelliJ for MAC

09:43
IntelliJ for Linux

10:22
Introduction to Data Structures

02:53
Introduction to Algorithms

04:15

Arrays and Big-O Notation

Sort Algorithms

Introduction to Sort Algorithms

01:03
Bubble Sort (Theory)

08:50
Bubble Sort (Implementation)

11:34
Stable vs. Unstable Sort Algorithms

04:42
Selection Sort (Theory)

06:33
Selection Sort (Implementation)

05:02
Insertion Sort (Theory)

07:34
Insertion Sort (Implementation)

07:12
Shell Sort (Theory)

12:54
Shell Sort (Implementation)

10:49
Recursion

18:10
Merge Sort (Theory)

20:40
Merge Sort (Implementation)

28:09
Quick Sort (Theory)

08:58
Quick Sort (Implementation)

12:34
Counting Sort (Theory)

07:56
Counting Sort (Implementation)

08:35
Radix Sort (Theory)

11:12
Stable Counting Sort (Theory)

13:18
Radix Sort (Implementation)

14:05
Sorting Arrays Using the JDK

07:00
Sort Algorithms Challenge #1

01:11
Sort Algorithms Challenge #1 Solution

04:03
Sort Algorithms Challenge #2

00:49
Sort Algorithms Challenge #2 Solution

11:46
Sort Algorithms Challenge #3

01:12
Sort Algorithms Challenge #3 Solution

09:49

Lists

Introduction to Lists

02:49
Abstract Data Types

02:56
Array Lists

23:56
Vectors

06:48
Singly Linked Lists (Theory)

06:42
Singly Linked Lists (Implementation)

17:39
Doubly Linked Lists (Theory)

09:33
Doubly Linked Lists (Implementation)

21:47
The JDK LinkedList Class

12:34
Linked Lists Challenge #1

01:36
Linked Lists Challenge #1 Solution

09:29
Linked Lists Challenge #2

01:46
Linked Lists Challenge #2 Solution

07:31

Stacks

Queues

Hashtables

Introduction to Hashtables

00:23
Hashtables (Theory)

08:25
Hashtables (Array Implementation)

13:53
Linear Probing

21:14
Linear Probing – Removing Items

09:39
Linear Probing – Rehashing

11:03
Chaining

21:24
Hashtables and the JDK

16:52
Bucket Sort (Theory)

06:35
Bucket Sort (Implementation)

09:04
Hashtables Challenge #1

01:54
Hashtables Challenge #1 Solution

02:39
Hashtables Challenge #2

01:37
Hashtables Challenge #2 Solution

07:55

Search Algorithms

Trees

Introduction to Trees

00:55
Trees (Theory)

11:16
Binary Search Trees (Theory)

14:17
Binary Search Trees (Insertion)

10:50
Binary Search Trees (Traversal)

11:23
Binary Search Trees (Get Min Max)

10:28
Binary Search Trees (Delete Cases 1 and 2)

03:15
Binary Search Trees (Implement Cases 1 and 2)

09:11
Binary Search Trees (Delete Case 3)

08:51
Binary Seach Trees (Implement Case 3)

07:16
Trees and the JDK

03:44
Binary Search Trees Challenge #1

01:53
Binary Search Trees Challenge #1 Solution

02:49
Binary Search Trees Challenge #2

09:17

Heaps

Introduction to Heaps

00:29
Heaps (Theory)

07:50
Storing Heaps as Arrays

07:54
Heaps (Insert)

09:02
Heaps (Delete Theory)

06:55
Heaps (Delete)

20:06
Heaps (Peek)

05:19
Priority Queues

12:00
Heapsort (Theory)

04:54
Heapsort (Implementation)

07:16

Course Wrap-Up

Extra Information – Source code, and other stuff

Add this certificate to your resume to demonstrate your skills & increase your chances of getting noticed.

Student Ratings & Reviews

No Review Yet

About Course

What Will You Learn?

Course Content

Introduction

A Message from the Professor

Introduction From Tim Buchalka

Introduction to the Course

JDK8 for Windows

JDK8 for MAC

JDK8 for Linux

IntelliJ for Windows

IntelliJ for MAC

IntelliJ for Linux

Introduction to Data Structures

Introduction to Algorithms

Arrays and Big-O Notation

Introduction to Arrays

Big-O Notation

A Quick Review of Arrays in Java

Arrays in Memory

Big-O Values for Array Operations

Sort Algorithms

Introduction to Sort Algorithms

Bubble Sort (Theory)

Bubble Sort (Implementation)

Stable vs. Unstable Sort Algorithms

Selection Sort (Theory)

Selection Sort (Implementation)

Insertion Sort (Theory)

Insertion Sort (Implementation)

Shell Sort (Theory)

Shell Sort (Implementation)

Recursion

Merge Sort (Theory)

Merge Sort (Implementation)

Quick Sort (Theory)

Quick Sort (Implementation)

Counting Sort (Theory)

Counting Sort (Implementation)

Radix Sort (Theory)

Stable Counting Sort (Theory)

Radix Sort (Implementation)

Sorting Arrays Using the JDK

Sort Algorithms Challenge #1

Sort Algorithms Challenge #1 Solution

Sort Algorithms Challenge #2

Sort Algorithms Challenge #2 Solution

Sort Algorithms Challenge #3

Sort Algorithms Challenge #3 Solution

Lists

Introduction to Lists

Abstract Data Types

Array Lists

Vectors

Singly Linked Lists (Theory)

Singly Linked Lists (Implementation)

Doubly Linked Lists (Theory)

Doubly Linked Lists (Implementation)

The JDK LinkedList Class

Linked Lists Challenge #1

Linked Lists Challenge #1 Solution

Linked Lists Challenge #2

Linked Lists Challenge #2 Solution

Stacks

Introduction to Stacks

Stacks (Theory)

Stacks Implementation (Array)

Stacks Implementation (Linked List)

Stacks Challenge

Stacks Challenge Solution

Queues

Introduction to Queues

Queues (Theory)

Queues (Array Implementation)

Circular Queue Implementation (Part One)

Circular Queue Implementation (Part Two)

Queues and the JDK

Queues Challenge

Queues Challenge Solution

Hashtables