VOOZH about

URL: https://www.coursera.org/learn/packt-advanced-concepts-in-recursion-backtracking-and-oop-exikg

⇱ Advanced Concepts in Recursion, Backtracking, and OOP | Coursera

Advanced Concepts in Recursion, Backtracking, and OOP

Keep adding new skills with 10,000+ programs for $239 (usually $399). Save now.

Advanced Concepts in Recursion, Backtracking, and OOP

Included with

Ask Coursera

Gain insight into a topic and learn the fundamentals.
Advanced level

Recommended experience

3 weeks to complete
at 10 hours a week
Flexible schedule
Learn at your own pace
Gain insight into a topic and learn the fundamentals.
Advanced level

Recommended experience

3 weeks to complete
at 10 hours a week
Flexible schedule
Learn at your own pace

What you'll learn

  • Master advanced recursion techniques and their applications in solving complex problems.

  • Gain expertise in backtracking, solving problems like Sudoku and constraint satisfaction.

  • Understand and apply object-oriented programming principles such as inheritance, polymorphism, and encapsulation.

  • Work with data structures like linked lists, stacks, and binary trees to solve algorithmic challenges.

Details to know

Shareable certificate

Add to your LinkedIn profile

Recently updated!

February 2026

Assessments

8 assignments

Taught in English

Build your subject-matter expertise

This course is part of the Data Structures Algorithms in Java – SECRETS to Ace LeetCode Specialization
When you enroll in this course, you'll also be enrolled in this Specialization.
  • Learn new concepts from industry experts
  • Gain a foundational understanding of a subject or tool
  • Develop job-relevant skills with hands-on projects
  • Earn a shareable career certificate

There are 7 modules in this course

This course features Coursera Coach!

A smarter way to learn with interactive, real-time conversations that help you test your knowledge, challenge assumptions, and deepen your understanding as you progress through the course. In this course, you will explore advanced topics in recursion, backtracking, and object-oriented programming (OOP). You’ll dive deep into recursive techniques, starting with basic problems like Fibonacci numbers and binary search, and advancing to more complex challenges like quick sort, merge sort, and maze solving. Through various problem-solving exercises, you'll master recursion’s power to simplify problem-solving and improve efficiency. The course also covers the powerful technique of backtracking, emphasizing how to solve constraint satisfaction problems like Sudoku. You’ll then transition to object-oriented programming, learning about classes, objects, inheritance, encapsulation, and polymorphism—core principles that underpin modern software design. Additionally, the course explores data structures such as linked lists, stacks, queues, and binary trees, with a focus on their application in solving real-world problems. By working through a series of LeetCode problems, you’ll develop a strong grasp of algorithmic thinking and efficient coding techniques, including recursion, backtracking, and OOP. By the end of the course, you will be able to implement advanced recursion techniques, solve backtracking problems, apply object-oriented principles in code, and work with essential data structures like linked lists and binary trees to solve complex algorithmic challenges.

In this module, we will dive deep into recursion, exploring its powerful application in solving a wide range of problems. You will learn how recursion can be used for sorting (bubble sort, quick sort), searching (binary search), and advanced problems such as string permutations, maze problems, and complex coding interview challenges from companies like Google and Amazon.

What's included

14 videos2 readings1 assignment

14 videos•Total 430 minutes
  • Introduction to Recursion•30 minutes
  • Fibonacci Number•35 minutes
  • Binary Search using Recursion•24 minutes
  • Solving Basic Questions Using Recursion•83 minutes
  • Solving Array Questions Using Recursion•48 minutes
  • Solving Pattern Questions using Recursion•8 minutes
  • Bubble Sort using Recursion•8 minutes
  • Selection sort using Recursion•16 minutes
  • Merge sort using Recursion•36 minutes
  • Quick Sort using Recursion•23 minutes
  • Strings, Subsets, Sub Sequence using Recursion•45 minutes
  • Permutations using Recursion•14 minutes
  • Google and Amazon level problem on Recursion•22 minutes
  • Maze Problems•38 minutes
2 readings•Total 20 minutes
  • Introduction to the Course 'Advanced Concepts in Recursion, Backtracking, and OOP'•10 minutes
  • Full Specialization Resources•10 minutes
1 assignment•Total 15 minutes
  • Recursion Deep Dive - Assessment•15 minutes

In this module, we will introduce the concept of backtracking, a technique for building solutions incrementally and abandoning them when they no longer meet the problem’s constraints. You will also learn how to apply backtracking to problems like Sudoku and other constraint-based challenges.

What's included

2 videos1 assignment

2 videos•Total 79 minutes
  • Backtracking•49 minutes
  • Sudoku Solver (LeetCode Problem)•29 minutes
1 assignment•Total 15 minutes
  • BackTracking - Assessment•15 minutes

In this module, we will explore Object-Oriented Programming (OOP), providing a comprehensive understanding of concepts like classes, inheritance, and polymorphism. You will also dive into advanced topics like interfaces, exception handling, and the Java Collections Framework, which are essential for writing efficient, maintainable, and scalable Java applications.

What's included

7 videos1 assignment

7 videos•Total 327 minutes
  • Classes and Objects•63 minutes
  • Packages and 'Static' Keyword•52 minutes
  • Inheritance, Encapsulation, Polymorphism•54 minutes
  • Access Specifier, In-built Methods•31 minutes
  • Interfaces and Abstract Methods•41 minutes
  • Exception Handling, ArrayList Implementation•59 minutes
  • Java Collections Framework•27 minutes
1 assignment•Total 15 minutes
  • Object Oriented Programming - Learn in the Best Way - Assessment•15 minutes

In this module, we will focus on linked lists, a crucial data structure in computer science. You will learn how to implement and manipulate singly, doubly, and circular linked lists, while also solving problems like detecting cycles, merging sorted lists, and reversing lists, with both iterative and recursive approaches.

What's included

9 videos1 assignment

9 videos•Total 219 minutes
  • Singly, Doubly And Circular Linked List•114 minutes
  • Insert node in Linked List using Recursion•24 minutes
  • Removing Duplicates from Linked List•15 minutes
  • Merge 2 sorted Lists (LeetCode Problem)•10 minutes
  • Linked List Cycle (LeetCode problem)•17 minutes
  • Happy Number (Linked List)•8 minutes
  • Middle of Linked List (LeetCode Problem)•4 minutes
  • Sort List (LeetCode Problem)•6 minutes
  • Reversing Linked List•21 minutes
1 assignment•Total 15 minutes
  • Linked List - Assessment•15 minutes

In this module, we will introduce stacks and queues, essential linear data structures. You will learn to implement custom stacks and queues, including dynamic and circular variations, and explore their applications in solving problems like expression evaluation, depth-first search, and more.

What's included

2 videos1 assignment

2 videos•Total 79 minutes
  • Stacks, Custom Stack, Dynamic Stacks•37 minutes
  • Queues, Custom Queue, Circular Queues•42 minutes
1 assignment•Total 15 minutes
  • Stacks and Queues - Assessment•15 minutes

In this module, we will explore binary trees, one of the most important tree-based data structures used in various algorithms. You will learn how to perform essential tree operations, including counting nodes, calculating the sum of nodes, finding tree height, and solving problems like finding the diameter and checking for subtrees.

What's included

6 videos1 assignment

6 videos•Total 113 minutes
  • Binary Trees•58 minutes
  • Count Number of Nodes in Binary Tree•7 minutes
  • Sum of Nodes in Binary Tree•5 minutes
  • Height of Tree•7 minutes
  • Diameter of a tree•22 minutes
  • Subtree of a tree (LeetCode Problem)•13 minutes
1 assignment•Total 15 minutes
  • Binary Trees - Assessment•15 minutes

In this module, we will introduce binary search trees (BST), focusing on their structure and how they enable efficient searching, insertion, and deletion. You will learn how to implement and apply BST operations to optimize data handling and solve various algorithmic challenges.

What's included

1 video1 reading2 assignments

1 video•Total 56 minutes
  • Binary Search Tree•56 minutes
1 reading•Total 10 minutes
  • Conclusion to the Course 'Advanced Concepts in Recursion, Backtracking, and OOP'•10 minutes
2 assignments•Total 75 minutes
  • Full Course Assessment•60 minutes
  • Full Course Practice Assessment•15 minutes

Earn a career certificate

Add this credential to your LinkedIn profile, resume, or CV. Share it on social media and in your performance review.

Instructor

Offered by

Explore more from Algorithms

Why people choose Coursera for their career

👁 Image

Felipe M.

Learner since 2018
"To be able to take courses at my own pace and rhythm has been an amazing experience. I can learn whenever it fits my schedule and mood."
👁 Image

Jennifer J.

Learner since 2020
"I directly applied the concepts and skills I learned from my courses to an exciting new project at work."
👁 Image

Larry W.

Learner since 2021
"When I need courses on topics that my university doesn't offer, Coursera is one of the best places to go."
👁 Image

Chaitanya A.

"Learning isn't just about being better at your job: it's so much more than that. Coursera allows me to learn without limits."

Frequently asked questions

Recursion, backtracking, and object-oriented programming (OOP) are fundamental concepts in computer science and programming. Recursion involves solving a problem by breaking it down into smaller instances of the same problem, while backtracking is a problem-solving technique where solutions are built incrementally and discarded if they fail to meet the criteria. OOP is a programming paradigm that organizes code into classes and objects, making it easier to manage and scale. These techniques are highly relevant because they are used in a wide range of applications, from solving complex algorithmic problems to designing robust and maintainable software systems.

This course provides a deep dive into advanced concepts of recursion, backtracking, and object-oriented programming. It covers recursion techniques, including solving common problems such as the Fibonacci sequence, binary search, and sorting algorithms like quicksort and merge sort. It also explores backtracking methods with real-world examples like solving Sudoku. The course further covers essential OOP principles such as inheritance, polymorphism, and interfaces, as well as practical implementations using Java. Additionally, the course includes important data structures like linked lists, stacks, queues, and binary trees, all within the context of recursion and OOP.

Upon completion of this course, you will have a strong understanding of advanced recursion techniques, such as solving complex algorithmic problems and optimizing recursive solutions. You will also be able to implement backtracking algorithms for constraint satisfaction problems like Sudoku. In addition, you will gain proficiency in object-oriented programming, understanding how to structure and organize code efficiently. You will also have practical knowledge of data structures such as linked lists, stacks, queues, and binary trees, and be able to apply these concepts to real-world coding challenges and interviews.

To enroll in this course, you should have a basic understanding of programming, including familiarity with loops, conditionals, and functions. Since the course covers advanced topics like recursion, backtracking, and object-oriented programming, it is beneficial to have a prior understanding of basic algorithms and data structures, such as arrays and basic sorting algorithms.

This course is designed for intermediate to advanced learners who are comfortable with basic programming concepts and want to deepen their knowledge of algorithmic techniques and object-oriented design. It is ideal for those preparing for technical interviews, software engineers seeking to enhance their coding skills, or anyone looking to master recursive problem-solving and OOP in Java.

The course contains 24 hours of video content. Depending on your pace, it may take several weeks to complete, allowing you time to absorb the material, practice coding, and solve related problems. This timeframe gives you the flexibility to revisit concepts and deepen your understanding as you work through the examples and exercises.

Yes, you can preview the first video and view the syllabus before you enroll. You must purchase the course to access content not included in the preview.

If you decide to enroll in the course before the session start date, you will have access to all of the lecture videos and readings for the course. You’ll be able to submit assignments once the session starts.

Once you enroll and your session begins, you will have access to all videos and other resources, including reading items and the course discussion forum. You’ll be able to view and submit practice assessments, and complete required graded assignments to earn a grade and a Course Certificate.

If you complete the course successfully, your electronic Course Certificate will be added to your Accomplishments page - from there, you can print your Course Certificate or add it to your LinkedIn profile.

This course is currently available only to learners who have paid or received financial aid, when available.

Yes. In select learning programs, you can apply for financial aid or a scholarship if you can’t afford the enrollment fee. If fin aid or scholarship is available for your learning program selection, you’ll find a link to apply on the description page.

Financial aid available,