CF

Algorithms in Java: Live problem solving & Design Techniques

19h 41m 26s
English
Paid

Algorithm Design Techniques: Engage in live problem-solving using Java. Algorithms underpin the technology around us. A single, well-applied algorithm can create transformative systems like Google! Expert computer scientists have developed techniques over centuries that are foundational to algorithm design. Why reinvent the wheel? In this course, we'll explore these renowned design techniques.

Course Overview

Understanding these algorithm design techniques will empower you to effectively tackle problems by identifying and applying the appropriate solution strategy. Here’s what you'll learn:

Key Design Techniques

  • Complexity Analysis: Grasp the importance of evaluating algorithm efficiency.
  • Recursion: The cornerstone of many algorithms, recursion helps simplify complex problems.
  • Backtracking: Learn to solve problems incrementally by exploring potential solutions and retracting when necessary.
  • Divide and Conquer: Break down problems into smaller, manageable parts for easier solution.
  • Greedy Algorithms: Build solutions piece by piece by choosing the most advantageous option at each step.
  • Dynamic Programming: Optimize solutions by storing results of previously solved sub-problems.

Throughout the course, we will write each line of code in Java!

Course Outcomes

By the conclusion of this course, you will:

  1. Have a solid understanding of designing effective algorithms.
  2. Gain extensive hands-on coding experience and solve real-world problems using Java.
  3. Develop the skills to perform algorithm complexity analysis.

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 163 lessons

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: Course Introduction
All Course Lessons (163)
#Lesson TitleDurationAccess
1
Course Introduction Demo
04:08
2
Introduction to Algorithms
03:50
3
Section Introduction
01:15
4
Complexity Analysis 1
07:42
5
Complexity Analysis 2
14:04
6
Section Summary
01:14
7
Section Introduction
00:38
8
Recurrence Relation
05:39
9
Solving Recurrence Relation
11:19
10
Master's Theorem
05:36
11
Section Summary
00:31
12
Section Introduction
01:57
13
Recursion
07:01
14
Identification
06:10
15
Approaching
04:36
16
Problem 01 : FindingSubsequences - Logic
04:07
17
Problem 01 : FindingSubsequences - Live Code Java
05:40
18
Problem 01 : FindingSubsequences - Complexity Analysis
02:21
19
Problem 02: Tower of Hanoi - Logic
05:39
20
Problem 02 : Tower of Hanoi - Live Code Java
04:49
21
Problem 02 : Tower of Hanoi - Complexity Analysis
11:11
22
Problem 03 : 7.Array Product Sum - Logic
04:32
23
Problem 03 : 7.Array Product Sum - Live Code Java
05:00
24
Problem 03 : Array Product Sum - Complexity Analysis
01:08
25
Problem 04 : Binary Subtree - Logic
06:23
26
Problem 04 : Binary Subtree - Live Code Java
08:25
27
Problem 04 : Binary Subtree - Complexity Analysis
00:58
28
Why and Why not Recursion
01:19
29
Types Of Recursion
04:02
30
Tail Recursion
05:19
31
Section Summary
01:01
32
Section Introduction
01:28
33
Introduction to Backtracking
01:45
34
Identify Backtracking
03:04
35
Approching the Solution
09:37
36
Problem 01 : Rat In Maze - Logic
08:41
37
Problem 01 : Rat In Maze - Code
08:45
38
Problem 01 : Rat In Maze - Complexity Analysis
01:20
39
Problem 02 : NQueen - Logic
08:44
40
Problem 02 : NQueen - Live Code in Java
08:10
41
Problem 02 : NQueen - Complexity Analysis
02:09
42
Problem 03 : Knights Tour Problem - Logic
05:02
43
Problem 03 : Knights Tour Problem - Live Code in Java
07:01
44
Problem 03 : Knight Tour Problem - Complexity Analysis
00:52
45
Problem 04 : Boggle | Word Search - Logic
05:49
46
Problem 04 : Boggle | Word Search - Live Code in Java
07:44
47
Problem 04 : Boggle | Word Search - Complexity Analysis
00:53
48
Section Summary
01:10
49
Section Introduction
00:45
50
Introduction To Divide And Conquer
03:16
51
Identification and Approaching
03:33
52
Problem 01 : MergeSort - Logic
09:34
53
Problem 01 : MergeSort - Live Java Code
08:43
54
Problem 01 : MergeSort - Complexity Analysis
04:22
55
Problem 02 : QuickSort - Logic
11:06
56
Problem 02 : QuickSort - Live Java Code
06:13
57
Problem 02 : QuickSort - Complexity Analysis
02:30
58
Problem 03 : Median Of Medians - Logic
09:01
59
Problem 03 : Median Of Medians - Live Java Code
14:53
60
Section Summary
00:43
61
Section Introduction
00:57
62
Introduction to Greedy
05:23
63
Identification & Approaching the Solution
03:08
64
Problem 01 : Fractional Knapsack - Logic
06:24
65
Problem 01 : Fractional Knapsack - Live Code Java
09:37
66
Problem 01 : Fractional Knapsack - Complexity Analysis
00:58
67
Problem 02 : IntervalScheduling - Logic
03:12
68
Problem 02 : IntervalScheduling - Live Code Java
07:48
69
Problem 02 : IntervalScheduling - Complexity Analysis
01:39
70
Problem 03 : Huffman Code - Logic
12:27
71
Problem 03 : Huffman Code - Live Code Java
19:04
72
Problem 03 : Huffman Code - Complexity Analysis
01:50
73
Problem 04 : Dijkstra - Logic
09:22
74
Problem 04 : Dijkstra Logic - Live Code
08:59
75
Problem 04 : Dijkstra - Complexity Analysis
01:02
76
Summary
00:43
77
Section Introduction
02:16
78
Introduction to Dynamic Programming
05:25
79
Identification
01:20
80
Compare DP D&C and Greedy
03:15
81
Approaching the Solution
03:44
82
Example 01 : Staircase Problem Theory & Live Code
15:42
83
Example 01 : Staircase Problem Complexity Analysis
03:05
84
Example 02 - 0/1 Knapsack Theory & Live code
26:36
85
Example 02 - 0/1 Knapsack Complexity Analysis
02:46
86
Example 03 - Coin Change Problem Theory and Code
25:35
87
Example 03 - Coin Change Problem Complexity Analysis
03:57
88
Example 04 : Longest Decreasing Subsequence Explanation And Code
27:55
89
Example 04 : Longest Decreasing Subsequence | Complexity Analysis
01:37
90
Example 05 : Levenshtein problem
23:29
91
Example 05 : Levenshtein Complexity Analysis
01:54
92
Example 06 : Rod Cutting
18:16
93
Example 06 : Rod Cutting - Complexity Analysis
01:42
94
Example 07 : Matrix Chain Multiplication
26:10
95
Example 07 : Matrix Chain Multiplication | Complexity Analysis
02:31
96
Summary
00:44
97
Kadane's Algo
07:40
98
Kadane's Algo Live Code Java
03:35
99
Kadane's Algo Complexity Analysis
00:34
100
BellmanFord's Algo
06:47
101
BellmanFord's Algo Live Code Java
11:20
102
BellmanFord's Algo Complexity Analysis
00:52
103
Topological Sort : Kahn's Algo
06:32
104
Topological Sort Live Code Java
13:54
105
Topological Sort Complexity Analysis
01:48
106
Edmond's Karp/Ford-Fulkerson Algorithm
26:35
107
Ford-Fulkerson Algorithm - Edmond's Karp Implementation
20:16
108
Tree Overview
23:28
109
Identification
02:02
110
Approaching Tree Problems
04:36
111
Problem 1: Sum Tree - Logic
09:29
112
Problem 1: Sum Tree - Live Code
04:55
113
Problem 2: Invert Binary Tree - Logic
02:20
114
Problem 2: Invert Binary Tree - Live Code
03:53
115
Problem 3: Binary Search Tree - Logic
11:46
116
Problem 3: Binary Search Tree - Live Code
16:19
117
Problem 4: Binary Tree from InOrder & LevelOrder - Logic
03:47
118
Problem 4: Binary Tree from InOrder & LevelOrder - Live Code
07:50
119
Graphs - In Real World
04:57
120
Graphs - Overview
11:54
121
Identification of Problem
03:54
122
Approaching the Problem
09:13
123
Mind-Map
02:36
124
Type - Graph Traversal
02:29
125
Depth First Search Traversal
06:18
126
DFS - Implementation (Recursive)
07:07
127
DFS - Implementation (Iterative)
04:50
128
Breadth First Search Traversal
03:27
129
BFS - Implementation
04:59
130
Type - Minimum Spanning Tree
05:30
131
Prim's Algorithm
09:29
132
Prim's Algorithm - Implementation
07:34
133
Kruskal's Algorithm
03:56
134
Union-Find Algorithm
08:10
135
Kruskal's Algorithm - Implementation
13:15
136
Type - Shortest Path
01:17
137
Dijkstra's Algorithm
09:22
138
Dijkstra's Algorithm - Implementation
08:59
139
BellmanFord's Algo
06:47
140
BellmanFord's Algo Live Code
11:20
141
Floyd Warshall Algorithm
06:46
142
Floyd-Warshall Algorithm - Implementation
05:47
143
Johnson's Algorithm
15:41
144
Johnson's Algorithm - Implementation
20:23
145
Type - Network Flow
04:40
146
Ford-Fulkerson Algorithm
26:35
147
Ford-Fulkerson Algorithm - Edmond's Karp Implementation
20:16
148
Max-Flow Min-Cut Theorem
05:46
149
Type - Strongly Connected Components
02:50
150
Tarjan's Algorithm
09:55
151
Tarjan's Algorithm - Implementation
12:25
152
Kosaraju's Algorithm
06:07
153
Kosaraju's Algorithm - Implementation
11:01
154
Section Introduction
01:20
155
Single Dimension Arrays
13:14
156
Multi Dimension Arrays
12:43
157
Declaration , Initialisation & Creation
19:04
158
Playing With Arrays Syntax Java
10:49
159
Traversing Arrays,Length of Array Java
13:35
160
Types of Array - based on elements it holds
11:53
161
Reassigning Array Objects to Array References
13:17
162
Anonymous Arrays
03:50
163
Arrays-Summay
00:49
Unlock unlimited learning

Get instant access to all 162 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 enrolling in this course?
Prospective students should have a basic understanding of Java programming, as all code examples and exercises are implemented in Java. Familiarity with fundamental programming concepts such as loops, conditionals, and data structures will also be beneficial for fully engaging with the course material.
What kind of projects or problems will I work on in the course?
Throughout the course, you will engage in solving a variety of algorithmic problems such as Finding Subsequences, Tower of Hanoi, Rat in Maze, N-Queen, Knight's Tour, Boggle Word Search, and different sorting algorithms like MergeSort and QuickSort. Each problem is tackled with live coding sessions in Java, followed by complexity analysis to understand the efficiency of the solutions.
Who is the target audience for this course?
The course is designed for individuals who wish to deepen their understanding of algorithm design techniques using Java. It is ideal for computer science students, software developers, and professionals interested in enhancing their problem-solving skills and understanding complex algorithmic concepts.
How does the depth and scope of this course compare to similar courses?
This course offers a structured approach to learning algorithm design techniques with a focus on live problem-solving. Unlike some courses that may only provide theoretical understanding, this course emphasizes practical application through coding exercises and complexity analysis, ensuring students gain hands-on experience in solving real-world problems.
What tools or platforms will I use during this course?
The course is conducted using Java as the primary programming language. Students are expected to have access to a Java development environment to follow along with coding exercises. Lessons will guide you through writing each line of code in Java, emphasizing the implementation of various algorithmic techniques.
What topics or areas are not covered in this course?
The course focuses specifically on algorithm design techniques and does not cover topics such as data structures in depth, machine learning, or system design. It is tailored towards understanding and applying different algorithmic strategies rather than exploring broader computer science topics.
How much time should I expect to commit to this course?
With a total of 163 lessons, the course requires a significant time commitment. Students should be prepared to invest several hours per week to fully engage with the lectures, coding exercises, and complexity analyses. The exact time will vary depending on the student's prior experience and familiarity with the material.