CF

Java Data Structures & Algorithms + LEETCODE Exercises

9h 47m 55s
English
Paid

Welcome to the Java Data Structures and Algorithms course! Embark on an exciting journey where complex programming concepts become accessible and engaging through innovative teaching techniques.

Course Highlights

Discover how this course transforms learning by combining traditional teaching methods with the magic of animation. These visual aids make complex material more visually accessible and engaging, helping you grasp concepts quickly and retain them longer.

Interactive Animations

The use of detailed animations in data structures and algorithms provides a visual platform that enhances understanding. You'll enjoy the learning process more and spend less time decoding complex topics.

Step-by-Step Guidance

I will personally guide you step-by-step through the material, ensuring that each concept is clear and understandable. This methodical approach ensures thorough comprehension and makes learning seamless.

Practical Programming Exercises

Put your newfound knowledge to the test with dozens of practical programming exercises. These exercises are designed for immediate application, reinforcing what you've learned and helping you to integrate theory with practice.

Interview Preparation

The course equips you with the skills and confidence needed for programming interviews. By the end, you'll feel more prepared to tackle questions confidently, showcasing your enhanced understanding and proficiency.

Join us and transform your programming skills today!

About the Author: Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

Watch Online 122 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 122 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Introduction
All Course Lessons (122)
#Lesson TitleDurationAccess
1
Introduction Demo
03:27
2
Overview (Please Watch)
06:18
3
Code Editor
09:22
4
Big O: Intro
02:57
5
Big O: Worst Case
01:37
6
Big O: O(n)
01:51
7
Big O: Drop Constants
01:35
8
Big O: O(n^2)
02:01
9
Big O: Drop Non-Dominants
02:09
10
Big O: O(1)
01:48
11
Big O: O(log n)
03:45
12
Big O: Different Terms for Inputs
02:24
13
Big O: Array Lists
04:55
14
Big O: Wrap Up
07:03
15
Classes
06:42
16
Pointers
05:52
17
Linked List: Intro
02:43
18
LL: Big O
06:01
19
LL: Under the Hood
02:19
20
LL: Constructor
09:19
21
LL: Print List
03:02
22
LL: Append
03:54
23
LL: Remove Last (Intro)
04:52
24
LL: Remove Last (Code)
09:33
25
LL: Prepend
03:44
26
LL: Remove First
06:28
27
LL: Get
04:22
28
LL: Set
04:31
29
LL: Insert
05:37
30
LL: Remove
07:17
31
LL: Reverse
05:50
32
DLL: Constructor
03:57
33
DLL: Append
04:13
34
DLL: Remove Last
07:56
35
DLL: Prepend
03:57
36
DLL: Remove First
04:56
37
DLL: Get
06:34
38
DLL: Set
03:53
39
DLL: Insert
05:46
40
DLL: Remove
06:15
41
Stack: Intro
05:21
42
Stack: Constructor
03:48
43
Stack: Push
03:10
44
Stack: Pop
02:49
45
Queue: Intro
02:37
46
Queue: Constructor
04:31
47
Queue: Enqueue
03:30
48
Queue: Dequeue
04:18
49
Trees: Intro & Terminology
04:24
50
Binary Search Trees: Example
02:34
51
BST: Big O
08:03
52
BST: Constructor
05:55
53
BST: Insert - Intro
05:33
54
BST: Insert - Code
09:53
55
BST: Contains - Intro
03:15
56
BST: Contains - Code
07:17
57
Hash Table: Intro
04:41
58
HT: Collisions
01:49
59
HT: Constructor
05:19
60
HT: Hash Method
04:14
61
HT: Set
05:42
62
HT: Get
06:10
63
HT: Keys
03:23
64
HT: Big O
02:15
65
HT: Interview Question
07:30
66
Graph: Intro
03:46
67
Graph: Adjacency Matrix
02:59
68
Graph: Adjacency List
01:26
69
Graph: Big O
07:10
70
Graph: Add Vertex
05:20
71
Graph: Add Edge
03:36
72
Graph: Remove Edge
03:38
73
Graph: Remove Vertex
06:59
74
Heap: Intro
06:04
75
Heap: Insert (Intro)
04:41
76
Heap: Helper Methods
02:42
77
Heap: Insert (Code)
06:09
78
Heap: Remove
05:00
79
Heap: Sink Down
08:53
80
Heap: Priority Queues & Big O
04:31
81
Recursion: Intro
06:59
82
Call Stack
07:16
83
Factorial
09:21
84
rBST: Contains
07:23
85
rBST: Insert
08:18
86
rBST: Delete Intro
02:21
87
rBST: Delete Code (1 of 3)
05:18
88
rBST: Delete Code (2 of 3)
04:50
89
rBST: Minimum Value
04:25
90
rBST: Delete Code (3 of 3)
05:24
91
Tree Traversal: Intro
01:28
92
BFS (Breadth First Search): Intro
03:09
93
BFS: Code
06:16
94
DFS (Depth First Search): PreOrder - Intro
01:11
95
DFS: PreOrder - Code
07:01
96
DFS: PostOrder - Intro
02:14
97
DFS: PostOrder - Code
05:32
98
DFS: InOrder - Intro
02:00
99
DFS: InOrder - Code
05:17
100
Bubble Sort: Intro
02:38
101
Bubble Sort: Code
05:38
102
Selection Sort: Intro
03:39
103
Selection Sort: Code
05:22
104
Insertion Sort: Intro
01:44
105
Insertion Sort: Code
04:39
106
Insertion Sort: Big O
01:21
107
Merge Sort: Overview
01:37
108
Merge: Intro
01:36
109
Merge: Code
05:37
110
Merge Sort: Intro
01:59
111
Merge Sort: Code
11:40
112
Merge Sort: Big O
03:24
113
Quick Sort: Intro
02:44
114
Pivot: Intro
03:31
115
Pivot: Code
05:36
116
Quick Sort: Code
06:13
117
Quick Sort: Big O
03:00
118
Overlapping Subproblems
04:53
119
Optimized Substructure
03:28
120
Fibonacci Sequence
09:58
121
Memoization
13:05
122
Bottom Up
07:10
Unlock unlimited learning

Get instant access to all 121 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What are the prerequisites for this course?
To make the most of this course, students should have a basic understanding of Java programming. Familiarity with concepts such as classes and pointers will be beneficial as these topics are part of the course curriculum. Additionally, having a basic grasp of algorithmic concepts might help in understanding the Big O notation covered in the lessons.
What types of projects or exercises will I work on?
The course includes dozens of practical programming exercises that reinforce the theoretical concepts taught. These exercises focus on applying data structures and algorithms, such as linked lists, stacks, queues, binary search trees, and hash tables. They are designed to provide hands-on experience and prepare students for programming interviews.
Who is the target audience for this course?
This course is ideal for Java programmers who want to deepen their understanding of data structures and algorithms. It caters to those preparing for technical interviews, as it covers both foundational concepts and practical exercises that mirror common interview questions. The course also appeals to students who prefer learning through visual aids and step-by-step guidance.
How does the scope of this course compare to similar courses?
Unlike many traditional courses, this one employs interactive animations to simplify complex topics in data structures and algorithms. The course spans 122 lessons, offering a breadth of content from basic concepts like Big O notation to more complex data structures such as binary search trees and hash tables. This extensive coverage prepares students thoroughly for real-world applications and interviews.
Does the course cover any specific tools or platforms?
The course includes a lesson on the 'Code Editor', which serves as a foundational tool for implementing programming exercises. However, it primarily focuses on the theoretical and practical aspects of data structures and algorithms rather than on specific software development tools or platforms.
What important topics are not covered in this course?
While the course provides comprehensive coverage of data structures and algorithms, it does not delve into advanced topics like graph algorithms or concurrent data structures. Additionally, it does not cover other programming languages beyond Java, nor does it include frameworks or libraries that might be used in enterprise-level applications.
How can the skills learned in this course benefit my career?
The skills acquired from this course, particularly in understanding data structures and algorithms, are essential for performance optimization and problem-solving in software development roles. Mastery of these concepts can enhance your ability to tackle technical interviews successfully, making you a strong candidate for competitive tech positions. Furthermore, these skills are fundamental and transferable across various programming languages and tech environments.