Divide and conquer is an algorithm design strategy built around a genuinely simple idea: break a large problem into smaller subproblems of the exact same type, solve each of those subproblems recursively, applying the same strategy again to each one, and then combine the subproblems' results into a solution for the original, full-size problem. This strategy turns problems that would be impractically slow to solve directly into ones a computer can handle efficiently, by shrinking the actual work at each step down to a manageable size.
Breaking a problem down repeatedly shrinks the work at each individual step
Rather than attacking an entire large problem in one pass, a divide-and-conquer algorithm splits it into smaller pieces, splits each of those pieces again, and keeps splitting until the resulting subproblems are small enough to solve directly and trivially, a single element, an empty list. This repeated splitting is exactly what a recursive function naturally expresses: the same function calls itself on progressively smaller pieces of the original problem, with each call doing genuinely less work than the one that spawned it.
Combining the small solutions back together is where the real efficiency actually comes from
Once the smallest subproblems have been solved directly, the strategy's final step merges their solutions back together into a solution for the next size up, and that merging repeats all the way back up to the original full-size problem. Because each individual subproblem is small, and the merging step at each level is typically fast, the total work across the whole divide-and-conquer process often turns out to be dramatically less than solving the original problem directly would require, which is exactly why divide and conquer underlies some of computer science's most efficient known algorithms for sorting and searching large datasets.
What we're still unsure about
That divide and conquer produces genuinely efficient algorithms for many classic computing problems is well established, extensively confirmed computer science taught consistently for decades. What's more genuinely a matter of ongoing algorithmic judgement is exactly when divide and conquer's overhead, splitting a problem apart and merging results back together, is actually worth paying versus when a simpler, more direct approach solves the same problem with less overall complexity, since dividing and merging aren't free operations themselves, and computer scientists continue to analyse and compare divide-and-conquer approaches against simpler alternatives on a problem-by-problem basis rather than divide and conquer being automatically the fastest choice for every problem it could technically be applied to.
This sits inside Divide & Conquer, one of eight topics in Algorithms, one of seven domains in Computer Science, one of seventeen subjects the app can quiz you on.