Data Structures & Algorithms !

Name: Data Structures & Algorithms !
Price: 12.75 USD
Availability: InStock
Rating: 5 (1 reviews)

28h 40m 46s

English

Paid

July 8, 2024

Data Structures & Algorithms ! is a 239-lesson 28 hours 40 minutes self-paced course by Udemy. Master the fundamentals of data structures and algorithms with this comprehensive course.

Course facts

Lessons: 239
Duration: 28 hours 40 minutes
Level: All levels
Language: English
Updated
Instructor: Udemy
Price: Premium

Master the fundamentals of data structures and algorithms with this comprehensive course. Whether you're a beginner or seeking to enhance your programming skills, this course will guide you from the basics to an intermediate level. While no prior experience in data structures or algorithms is required, a basic understanding of Java will be beneficial for maximizing your learning experience.

Course Overview

This course is meticulously designed to help learners build a strong foundation in data structures and algorithms. You'll start with essential concepts and progressively tackle more challenging topics, ensuring a well-rounded understanding by the end of the course.

What You'll Learn

Introduction to basic data structures
Advanced data structure techniques
Algorithm design and analysis
Problem-solving strategies

Who Should Enroll

This course is ideal for:

Beginners with no prior knowledge of data structures and algorithms
Intermediate learners aiming to refine their skills
Java programmers looking to enhance their coding proficiency

Prerequisites

While this course is beginner-friendly, having basic Java knowledge is recommended to help you grasp concepts more effectively. However, the course is structured in such a way that those without Java experience will still benefit significantly.

Who teaches Data Structures & Algorithms !? Udemy

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.

What lessons are included in Data Structures & Algorithms !?

0:00

#1: S01 - L01 -- Course Breakdown

All Course Lessons (239)

#	Lesson Title	Duration
1	S01 - L01 -- Course Breakdown Demo	07:09
2	S01 - L02 -- What is DS and Algo	04:37
3	S01 - L03 -- Why companies ask DS	03:28
4	S01 - L04 -- DS in every day life	03:30
5	S01 - L05 -- Types of DS	03:42
6	S01.1-L01--What is Recursion	11:59
7	S01.1-L02--Why learn Recursion	05:07
8	S01.1-L03--Format of Recursion Method	04:09
9	S01.1-L04--How Recurssion works internally	14:41
10	S01.1-L05--Finding Factorial using Recursion	08:22
11	S01.1-L06--Finding Fibonacci using Recursion	07:42
12	S01.1-L07--Recursion vs Iteration	03:19
13	S01.1-L08--When to Use & Avoid Recursion	04:43
14	S01.1-L09--Practical Uses of Recursion	03:16
15	S02-L01 -- What is Algo Run Time Analysis	03:14
16	S02-L02 -- What are Notations	10:39
17	S02-L03 -- Examples of Notations	07:55
18	S02-L04 -- Examples of Time Complexity	06:52
19	S02-L05 -- Finding Time Complexity of Iterative Algo	08:14
20	S02-L06 -- Finding Time Complexity of Recursive Algo#1	11:10
21	S02-L07 -- Finding Time Complexity of Recursive Algo#2	17:48
22	S03 - L01 -- What and Why of Array	07:02
23	S03 - L02 -- Types of Array	07:18
24	S03 - L03 -- How is Array represented in Memory	06:01
25	S03 - L04 -- Create an Array	11:26
26	S03 - L05 -- Insert Traverse in 1D Array	07:05
27	S03 - L06 -- Access Search Delete in 1D Array	16:27
28	S03 - L07 -- Code 1D Array	13:45
29	S03 - L08 -- Time Complexity of 1D Array	04:02
30	S03 - L09 -- Create 2D Array	09:14
31	S03 - L10 -- 2D Array operations	14:49
32	S03 - L11 -- Time Complexity of 2D Array	02:56
33	S03 - L12 -- When to use Array	06:17
34	S03 - L13 -- Code 2D Array	14:33
35	S03 - L14 -- Practical uses of Array	07:31
36	S04 - L01 -- What is linked list	08:44
37	S04 - L02 -- Linked list vs Array	03:19
38	S04 - L03 -- Components of LinkedList	06:30
39	S04 - L04 -- Types of LinkedList	06:55
40	S04 - L05 -- Why so many types of LinkedList	07:57
41	S04 - L06 -- How is LinkedList stored in Memory	05:06
42	S04 - L07 -- Creation of Single LinkedList (SLL)	05:57
43	S04 - L08 -- Insertion in SLL - Dry Run	07:24
44	S04 - L09 -- Insertion in SLL - Algo	10:57
45	S04 - L10 -- Traversal of SLL	03:50
46	S04 - L11 -- Search node in SLL	04:53
47	S04 - L12 -- Deletion of node from SLL - Dry Run	09:14
48	S04 - L13 -- Deletion of node from SLL - Algo	08:48
49	S04 - L14 -- Delete entire SLL	03:15
50	S04 - L15 -- Time Complexity of SLL	03:30
51	S04 - L16 -- Creation of Circular Single LinkedList (CSLL)	04:07
52	S04 - L17 -- Insertion of data in CSLL - Dry Run	06:16
53	S04 - L18 -- Insertion of data in CSLL - Algo	07:45
54	S04 - L19 -- Traverse CSLL	02:31
55	S04 - L20 -- Search a node in CSLL	04:54
56	S04 - L21 -- Delete a node from CSLL - Dry Run	05:35
57	S04 - L22 -- Deletion of node from CSLL - Algo	07:05
58	S04 - L23 -- Deletion of entire CSLL	04:02
59	S04 - L24 -- Time Complexity of CSLL	04:17
60	S04 - L25 -- Create Double Linked List (DLL)	05:59
61	S04 - L26 -- Insert node in DLL - Dry Run	08:00
62	S04 - L27 -- Insert node in DLL - Algo	13:35
63	S04 - L28 -- Traverse DLL	02:32
64	S04 - L29 -- Reverse Traversal of DLL	03:21
65	S04 - L30 -- Search a node in DLL	03:13
66	S04 - L31 -- Delete a node from DLL - Dry Run	07:21
67	S04 - L32 -- Delete a node from DLL - Algo	09:40
68	S04 - L33 -- Delete entire DLL	04:47
69	S04 - L34 -- Time Complexity of DLL	04:13
70	S04 - L35 -- Create Double Circular LinkedList (CDLL)	07:37
71	S04 - L36 -- Insert node in CDLL - Dry Run	11:06
72	S04 - L37 -- Insert node in CDLL - Algo	09:46
73	S04 - L38 -- Traverse CDLL	03:36
74	S04 - L39 -- Reverse traverse CDLL	03:28
75	S04 - L40 -- Search a node in CDLL	04:31
76	S04 - L41 -- Delete a node from CDLL - Dry Run	08:45
77	S04 - L42 -- Delete a node from CDLL - Algo	10:38
78	S04 - L43 -- Delete entire CDLL	06:29
79	S04 - L44 -- Time Complexity of CDLL	04:27
80	S04 - L45 -- SLL vs CSLL vs DLL vs DLL	06:43
81	S04 - L46 -- Practical uses of LinkedList	05:10
82	L01 -- What and Why of Stack	04:55
83	L02 -- ARRAY - Create & Push	06:19
84	L03 -- ARRAY - Pop, Peek, isEmpty, isFull, Delete	07:52
85	L04 -- LinkedList - Create, Push, Pop	06:36
86	L05 -- LinkedList - Peek, Delete	05:06
87	L06 -- When to use or avoid Stack	03:36
88	S06 - L01 -- What and Why of Queue	03:53
89	S06 - L02 -- LINEAR QUEUE(Array) - Create, Enqueue	06:59
90	S06 - L03 -- LINEAR QUEUE((Array)) - deQueue, isEmpty, isFull, Delete	07:23
91	S06 - L04 -- Why Circular Queue	04:45
92	S06 - L05 -- CIRCULAR QUEUE(Array) - Enqueue	05:57
93	S06 - L06 -- CIRCULAR QUEUE(Array) - Dequeue	03:19
94	S06 - L07 -- CIRCULAR QUEUE(Array) - Peek, isEmpty, isFull, Delete	05:22
95	S06 - L08 -- LINEAR QUEUE(LL) - Enqueue	05:31
96	S06 - L09 -- LINEAR QUEUE(LL) - DeQueue	03:11
97	S06 - L10 -- LINEAR QUEUE(LL) - Peek, isEmpty, Delete	04:04
98	S06 - L11 -- Array vs LinkedList Implementation	04:29
99	S08.01 - L01 -- What is Tree	09:30
100	S08.01 - L02 -- Why learn Tree	02:08
101	S08.01 - L03 -- Tree Terminologies - Part#1	10:01
102	S08.01 - L03 -- Tree Terminologies - Part#2	04:29
103	S08.01 - L04 -- What & Why of Binary Ttree	04:15
104	S08.01 - L05 -- Types of Binary Tree	05:29
105	S08.01 - L06 -- How is Tree Represented in Code	08:54
106	S08.01 - L07 -- Create blank Binary Tree(LL)	03:17
107	S08.01 - L08 -- Pre-order traversal Binary Tree(LL)	14:45
108	S08.01 - L09 -- In-order traversal Binary Tree(LL)	06:18
109	S08.01 - L10 -- Post-order traversal Binary Tree(LL)	06:33
110	S08.01 - L11 -- Level-order traversal Binary Tree(LL)	07:26
111	S08.01 - L12 -- Search for value in Binary Tree(LL)	08:10
112	S08.01 - L13 -- Insert value in Binary Tree(LL)	05:54
113	S08.01 - L14 -- Delete value from Binary Tree(LL)	06:55
114	S08.01 - L15 -- Delete Binary Tree(LL)	03:59
115	S08.01 - L16 -- Create Binary Tree(Array)	05:14
116	S08.01 - L17 -- Insert value in Binary Tree(Array)	05:55
117	S08.01 - L18 -- Search for value in Binary Tree(Array)	03:39
118	S08.01 - L19 -- Inorder traversal of Binary Tree(Array)	06:18
119	S08.01 - L20 -- Pre-order traversal of Binary Tree(Array)	03:48
120	S08.01 - L21 -- Post-order traversal of Binary Tree(Array)	04:18
121	S08.01 - L22 -- Level-order traversal of Binary Tree(Array)	02:46
122	S08.01 - L23 -- Delete node from Binary Tree(Array)	05:34
123	S08.01 - L24 -- Delete Binary Tree(Array)	03:26
124	S08.01 - L25 -- Binary Tree (Array vs Linked List)	04:44
125	S08.02 - L01 -- What & Why of BST	04:45
126	S08.02 - L02 -- Creation & Searching in BST	10:00
127	S08.02 - L03 -- Traversing a BST	07:37
128	S08.02 - L04 -- Inserting a node in BST	13:58
129	S08.02 - L05 -- Deleting a node from BST	15:55
130	S08.02 - L06 -- Deleting a BST	03:43
131	S08.03 - L01 -- Why learn AVL Tree	06:49
132	S08.03 - L02 -- What is AVL Tree	10:21
133	S08.03 - L03 -- Create Search Traverse AVL Tree	06:28
134	S08.03 - L04 -- Insert in AVL_LL Theory	12:02
135	S08.03 - L05 -- Insert in AVL_LL Algorithm	04:48
136	S08.03 - L06 -- Insert in AVL LR	08:13
137	S08.03 - L07 -- Insert in AVL RR	08:24
138	S08.03 - L08 -- Insert in AVL RL	06:23
139	S08.03 - L09 -- Insert End to End Case	14:20
140	S08.03 - L10 -- Delete LL LR RR RL	11:27
141	S08.03 - L11 -- Delete End to End Case	11:57
142	S08.03 - L12 -- Delete AVL Tree & Tree Comparison	07:37
143	S08.04 - L01 -- What Why and Type of Heap	12:27
144	S08.04 - L02 -- Create, Peek, Size of Heap	04:45
145	S08.04 - L03 -- Insert element in Heap	05:12
146	S08.04 - L04 -- Extract and Delete from Heap	06:04
147	S08.04 - L05 -- Why avoid Reference based implementation ?	03:50
148	S08.05 - L01 -- What and Why of Trie	05:57
149	S08.05 - L02 -- Create Insert in Trie	06:53
150	S08.05 - L03 -- Search a String in Trie	02:36
151	S08.05 - L04 -- Delete a String from Trie	07:38
152	S08.05 - L05 -- Practical Uses of Trie	02:33
153	S09 - L01 -- Introduction to Hashing	03:39
154	S09 - L02 -- Why learn Hashing ?	05:13
155	S09 - L03 -- Introduction to Hash Functions	08:53
156	S09 - L04 -- Types of Collision Resolution Techniques	14:55
157	S09 - L05 -- What happens when Hash Table is full ?	04:31
158	S09 - L06 -- Collision Resolution Techniques Compared	08:27
159	S09 - L07 -- Practical Use of Hashing	06:41
160	S09 - L08 -- Hashing vs Other DS	04:37
161	S10 - L01 -- What and Why of Sorting	03:55
162	S10 - L02 -- Types of Sorting Techniques	07:15
163	S10 - L03 -- Sorting Terminologies	05:02
164	S10 - L04 -- Bubble Sort	07:47
165	S10 - L05 -- Selection Sort	06:08
166	S10 - L06 -- Insertion Sort	08:52
167	S10 - L07 -- Bucket Sort	08:35
168	S10 - L08 -- Merge Sort	11:12
169	S10 - L09 -- Quick Sort Part#1	12:37
170	S10 - L09 -- Quick Sort Part#2	06:01
171	S10 - L10 -- HeapSort	12:42
172	S10 - L11 -- Sorting Techniques compared	02:15
173	S11 - L01 -- What and Why of Graphs	08:57
174	S11 - L02 -- Graph Terminologies	05:12
175	S11 - L03 -- Types of Graphs	04:00
176	S11 - L04 -- Graph Representation in Code	07:09
177	S11 - L05 -- BFS Algorithm	08:30
178	S11 - L06 -- BFS Time Complexity	06:34
179	S11 - L07 -- DFS Algorithm	08:08
180	S11 - L08 -- DFS Time Complexity	05:59
181	S11 - L09 -- BFS vs DFS	04:27
182	S11 - L10 -- What is Topological Sort	03:45
183	S11 - L11 -- Topological Sort Dry Run	06:33
184	S11 - L12 -- Why Topological Sort Works	07:12
185	S11 - L13 -- Topological Sort Algorithm	06:39
186	S11 - L14 -- What is Single Source Shortest Path Problem(SSSP)	06:30
187	S11 - L15 -- BFS for SSSP	08:08
188	S11 - L16 -- Why BFS does not works for Weighted Graph SSSP	04:04
189	S11 - L17 -- Why DFS does not works for SSSP	03:02
190	S11 - L18 -- Dijkstra for SSSP	11:17
191	S11 - L19 -- Why Dijkstra does not work for Negative Cycle	06:07
192	S11 - L20 -- BellmanFord Dry run for SSSP	09:48
193	S11 - L21 -- BellanFord Algorithm for SSSP	04:28
194	S11 - L22 -- How Bellman Ford works for Negative Cycle	09:09
195	S11 - L23 -- Why BellmanFord runs for V-1 times	10:09
196	S11 - L24 -- BFS vs Dijkstra vs BellmanFord	04:33
197	S11 - L25 -- What is All Pair Shortest Path Problem(APSP)	05:35
198	S11 - L26 -- Dry run of BFS Dijkstra Bellman for APSP	05:18
199	S11 - L27 -- Floyd Warshall Algorithm for APSP	10:09
200	S11 - L28 -- Why Floyd Warshall Algorithm always works	08:13
201	S11 - L29 -- Why Floyd does not works for Negative Cycle	03:50
202	S11 - L30 -- BFS vs Dijkstra vs Bellman vs Floys	04:25
203	S11 - L31 -- What is Minimum Spanning Tree (MST)	04:39
204	S11 - L32.1 -- DisjointSet	08:49
205	S11 - L32.2 -- Kruskals Algorithm	12:40
206	S11 - L33 -- Prims Algorithm Dry Run	06:34
207	S11 - L34 -- Prims Algorithm Explained	05:23
208	S11 - L35 -- Prims vs Kruskal	02:34
209	S12.1 - L01 -- Magic Framework	04:46
210	S12.2 - L01 -- Greedy Algo Introduction	06:18
211	S12.2 - L02 -- Known Algos	10:51
212	S12.2 - L03 -- Activity Selection Problem	08:05
213	S12.2 - L04 -- Coin Change Problem	09:07
214	S12.2 - L05 -- Fractional Knapsack Problem	11:56
215	S12.3 - L01 -- What and Why of Divide&Conquer	07:35
216	S12.3 - L02 -- Binary Search, Quick, Merge Sortt	05:48
217	S12.3 - L03 -- Fibonacci Series	03:32
218	S12.3 - L04 -- Number Factor	09:38
219	S12.3 - L05 -- House thief	08:49
220	S12.3 - L06 -- Convert One String to Another	12:58
221	S12.3 - L07 -- Zero-One Knapsack	07:49
222	S12.3 - L08 -- Longest Common Subsequence	08:52
223	S12.3 - L09 -- Longest Palindromic Subsequence	09:47
224	S12.3 - L10 -- Longest Palindromic Substring	09:11
225	S12.3 - L11 -- Min Cost to Reach End of Array	07:13
226	S12.3 - L12 -- Number of Paths to reach last cell with given Cost	10:30
227	S12.4 - L01 -- What and Why of Dynamic Programming	04:46
228	S12.4 - L02 -- Top Down Approach	06:41
229	S12.4 - L03 -- Bottom Up Approach	07:45
230	S12.4 - L04 -- Is Merge Sort Dynamic Programming ?	03:57
231	S12.4 - L05 -- Number Factor Problem	15:26
232	S12.4 - L06 -- HouseThief Problem	12:15
233	S12.4 - L07 -- Convert One String to Another	11:20
234	S12.4 - L08 -- Zero One Knapsack Problem	13:16
235	S12.4 - L09 -- Longest Common Subsequence	10:20
236	S12.4 - L10 -- Longest Palindromic Subsequence	10:53
237	S12.4 - L11 -- Longest Palindromic Substring	12:34
238	S12.4 - L12 -- Min Cost to Reach End of Array	12:35
239	S12.4 - L13 -- Ways to Reach last cell	24:53

Unlock unlimited learning

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

Learn more about subscription

What courses are similar to Data Structures & Algorithms !?

Updated 2y ago
Java Foundations: The Complete Course with Java 21 Updates
By: Udemy
This course is designed for absolute beginners in programming and for those who don't mind learning Java at a slower pace.
88h 37m
Updated 2y ago
Learn Blockchain Technology & Cryptocurrency in Java
By: Udemy
Blockchain is a revolutionary technology that allows for decentralized and distributed storage of information. Maybe the hottest topic at the moment in the fiel
5h 44m
Updated 2y ago
Data Structures and Algorithms: Deep Dive Using Java
By: Udemy
So you've worked with the basics of data structures and algorithms in Java (or another OO programming language) but feel like you need a deeper knowledge
15h 53m

Frequently asked questions

What are the prerequisites for enrolling in this course?

While this course is designed to be beginner-friendly, having a basic understanding of Java is recommended. This foundational knowledge will help you grasp the concepts of data structures and algorithms more effectively. However, even without prior Java experience, students can benefit significantly from the course structure.

What types of projects or exercises will I work on during the course?

The course includes practical exercises such as finding factorial and Fibonacci numbers using recursion, as well as creating and manipulating different types of arrays and linked lists. These exercises are designed to reinforce the theoretical concepts covered in the lessons.

Who is the ideal audience for this course?

The course is ideal for beginners with no prior knowledge of data structures and algorithms, intermediate learners looking to refine their skills, and Java programmers aiming to enhance their coding proficiency.

How does the depth of this course compare to similar courses?

This course offers a thorough introduction to both basic and advanced data structure techniques, as well as algorithm design and analysis. It aims to build a strong foundation, making it suitable for beginners and those seeking to advance to an intermediate level.

What specific tools or platforms are covered in the course?

The course involves working with Java as the primary programming language for implementing data structures and algorithms. It covers fundamental concepts like recursion, arrays, and linked lists with detailed insights into their memory representation and time complexity analysis.

What topics are not covered in the course?

The course focuses on foundational and intermediate topics in data structures and algorithms. It does not cover advanced topics such as graph algorithms, dynamic programming, or concurrent data structures, which may be explored in more advanced courses.

What is the estimated time commitment required to complete the course?

The course consists of 239 lessons. While the total runtime is not specified, students should expect to dedicate time to both the video lessons and accompanying exercises to fully grasp the material. A consistent study schedule will aid in progressing through the course effectively.