CF

Recursion, Backtracking and Dynamic Programming in Java

9h 46m 17s
English
Paid
Updated September 2026

Recursion, Backtracking and Dynamic Programming in Java is a 82-lesson 9 hours 46 minutes self-paced course by Udemy. Recursion, backtracking, dynamic programming, and divide-and-conquer are the algorithmic techniques that show up again and again, from software engineering interviews to fields like investment banking and R&D.

Course facts

Lessons
82
Duration
9 hours 46 minutes
Level
All levels
Language
English
Updated
2026-09-11
Instructor
Udemy
Price
Premium

Recursion, backtracking, dynamic programming, and divide-and-conquer are the algorithmic techniques that show up again and again, from software engineering interviews to fields like investment banking and R&D. This course goes through each one in Java, working problem by problem rather than staying abstract.

What's covered

  • Recursion: stack vs. heap memory, stack overflow, Fibonacci numbers, factorials, and the Tower of Hanoi
  • Search and selection algorithms: linear and binary search, quickselect, and the median-of-medians algorithm
  • Backtracking: the N-Queens problem, Hamiltonian cycles, graph coloring, the Knight's Tour, and Sudoku solving
  • Dynamic programming: the knapsack problem, rod cutting, and subset sum
  • Optimal packing: the bin packing problem
  • Divide and conquer: merge sort and the closest-pair problem

82 lessons total, aimed at developers preparing for technical interviews or wanting a firmer grip on classic algorithmic problem-solving.

Section 1 - RECURSION

  • what are recursion and recursive methods

  • stack memory and heap memory overview

  • what is stack overflow?

  • Fibonacci numbers

  • factorial function

  • tower of Hanoi problem

Section 2 - SEARCH ALGORITHMS

  • linear search approach

  • binary search algorithm

Section 3 - SELECTION ALGORITHMS

  • what are selection algorithms?

  • how to find the k-th order statistics in O(N) linear running time?

  • quickselect algorithm

  • median of medians algorithm

  • the secretary problem

Section 4 - BACKTRACKING

  • what is backtracking?

  • n-queens problem

  • Hamiltonian cycle problem

  • coloring problem

  • knight's tour problem

  • Sudoku game

Section 5 - DYNAMIC PROGRAMMING

  • what is dynamic programming?

  • knapsack problem

  • rod cutting problem

  • subset sum problem

Section 6 - OPTIMAL PACKING

  • what is optimal packing?

  • bin packing problem

Section 7 - DIVIDE AND CONQUER APPROACHES

  • what is the divide and conquer approach?

  • dynamic programming and divide and conquer method

  • how to achieve sorting in O(NlogN) with merge sort?

  • the closest pair of points problem

Section 8 - COMMON INTERVIEW QUESTIONS

  • top interview questions (Google, Facebook and Amazon)

In each section we will talk about the theoretical background for all of these algorithms then we are going to implement these problems together from scratch in Java.

Finally, YOU CAN LEARN ABOUT THE MOST COMMON INTERVIEW QUESTIONS (Google, MicroSoft, Amazon etc.)

Who teaches Recursion, Backtracking and Dynamic Programming in Java? 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.

What lessons are included in Recursion, Backtracking and Dynamic Programming in Java?

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: Introduction
All Course Lessons (82)
#Lesson TitleDurationAccess
1
Introduction Demo
02:09
2
What are stack and heap memory?
03:45
3
Stack memory and heap memory simulation
06:15
4
Recursion introduction
08:44
5
Adding numbers: iteration vs recursion
05:05
6
Recursion and stack memory (stack overflow)
10:10
7
Head recursion and tail recursion implementation
06:39
8
Factorial function - head recursion
06:07
9
Factorial problem - visualizing the stack
04:15
10
Factorial function - tail recursion
05:48
11
Fibonacci numbers - head recursion
04:58
12
Towers of Hanoi problem introduction
06:01
13
Tower of Hanoi problem implementation
05:39
14
Towers of Hanoi - visualizing the stack
07:09
15
Iteration and recursion revisited
01:43
16
What is linear search?
01:39
17
Linear search implementation
03:17
18
What is binary (logarithmic) search?
03:49
19
Binary search implementation
08:54
20
Selection algorithms introduction
06:44
21
Quickselect introduction - Hoare algorithm
09:49
22
Quickselect visualization
08:52
23
Quickselect implementation
11:57
24
What the problem with pivots?
05:50
25
Advanced selection - median of medians algorithm
07:31
26
Combining algorithms - introselect algorithm
01:23
27
Online selection - the secretary problem
08:02
28
Backtracking introduction
05:51
29
Brute-force search and backtracking
04:03
30
N-queens problem introduction
08:07
31
What is the search tree?
03:10
32
N-queens problem implementation I
09:22
33
N-queens problem implementation II
06:17
34
N-queens problem and stack memory visualization
06:22
35
Hamiltonian paths (and cycles) introduction
08:03
36
Hamiltonian cycle illustration
04:42
37
Hamiltonian cycle implementation I
10:17
38
Hamiltonian cycle implementation II
07:02
39
Coloring problem introduction
08:49
40
Coloring problem visualization
04:33
41
Coloring problem implementation I
07:18
42
Coloring problem implementation II
05:25
43
Knight's tour introduction
03:55
44
Knight's tour implementation I
10:33
45
Knight's tour implementation II
04:49
46
Maze problem introduction
04:59
47
Maze problem implementation I
07:22
48
Maze problem implementation II
06:53
49
Sudoku introduction
05:52
50
Sudoku implementation I
08:38
51
Sudoku implementation II
03:28
52
What is the issue with NP-complete problems?
05:05
53
Dynamic programming introduction
08:24
54
Fibonacci numbers introduction
03:31
55
Fibonacci numbers implementation
08:36
56
Knapsack problem introduction
18:08
57
Knapsack problem example
12:59
58
Knapsack problem implementation I
08:08
59
Knapsack problem implementation II
04:27
60
Rod cutting problem introduction
08:04
61
Rod cutting problem example
11:07
62
Rod cutting problem implementation
08:46
63
Subset sum problem introduction
10:12
64
Subset sum problem example
09:09
65
Subset sum problem implementation
09:05
66
Bin packing problem introduction
08:10
67
Bin packing problem implementation
06:53
68
What are divide-and-conquer approaches?
09:24
69
Binary search revisited
01:46
70
Merge sort theory
08:18
71
Merge sort implementation
06:27
72
Closest pair of points problem introduction I
15:21
73
Closes pair of points problem introduction II
04:15
74
Closest pair of points implementation
23:54
75
Palindrome problem solution
08:01
76
Integer reversion solution
07:01
77
Two eggs problem solution I
08:02
78
Two eggs problem solution II
11:40
79
Duplicates in an array problem solution
07:57
80
Anagram problem solution
03:52
81
Largest sum subarray problem solution
10:49
82
What is Algorhyme?
00:42
Unlock unlimited learning

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

Learn more about subscription

What courses are similar to Recursion, Backtracking and Dynamic Programming in Java?

More courses by Udemy

Frequently asked questions

What are the prerequisites for this course?
Before enrolling in this course, students should have a basic understanding of Java programming. Familiarity with core concepts like variables, loops, and functions will be beneficial. The course assumes that students have some prior programming knowledge, as it delves into algorithmic concepts such as recursion, backtracking, and dynamic programming.
What is the time commitment required for this course?
The course consists of 82 lessons. While the exact runtime is not specified, students should expect to invest several hours per week to fully understand the material. This includes watching video lessons, practicing coding exercises, and reviewing concepts covered in areas such as recursion, backtracking, and dynamic programming.
What types of projects will I work on in this course?
Students will work on implementing various algorithmic problems, such as the Towers of Hanoi, the N-queens problem, the Hamiltonian cycle, and the Knight's tour. These projects are designed to apply the concepts of recursion, backtracking, and dynamic programming, providing practical experience with these complex algorithmic techniques.
What is not covered in this course?
The course does not cover introductory programming topics such as basic syntax or simple data structures in Java. It also does not delve into advanced topics outside the scope of recursion, backtracking, and dynamic programming, such as advanced data structures or machine learning algorithms.
How does this course differ from other algorithm courses?
This course focuses specifically on recursion, backtracking, and dynamic programming, offering detailed implementations of problems like the Sudoku solver and the Knapsack problem. It provides a deep dive into these algorithmic techniques, which may not be covered as extensively in more general algorithm courses.
What are the benefits of learning these techniques for careers?
Understanding recursion, backtracking, and dynamic programming is crucial for careers in fields like software engineering, R&D, and finance. These techniques are fundamental for solving complex computational problems and are widely applicable in areas such as optimization, resource allocation, and artificial intelligence.
What specific tools or platforms will be used in this course?
The course is taught using the Java programming language. Students will engage with various algorithmic problems through Java, leveraging its capabilities to implement and solve recursive, backtracking, and dynamic programming challenges effectively.